#Published by Sina Ahmadi Neshat / Hazyoon.ir
//......................HEADER FILES............................
#define SIZE 20
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<stdlib.h>


//.......................CONVERSION FUNCTIONS......................
void binary_decimal_fun();
void decimal_binary_fun();
int binary_decimal(int binary_number);
int decimal_binary(int decimal_number);
void binary_addition_fun();
int binary_addition(int binary_number1, int binary_number2);
void binary_subtraction();

//.......................FUNCTION FOR VALIDATION CHECK....................

int number_scanning_check();	//........FUNCTION WILL RETURN A VALUE OF INTERGER TYPE.......
int binary_number_scanning_check();

//.......................STRING FUNCTIONS..........................

void add_string();
void delete_string();
void search_character();
void replace_character();
void string_cat(char temp1_string[SIZE], char temp2_string[SIZE]);
int check_length(char temp1_string[SIZE]);

struct search_char{

	char temp_string[SIZE];
	int  char_count;
}node;

//.......................MATRIX FUNCTIONS.........................

void matrix_addition();
void matrix_subtraction();
void multiplication();
void matrix_inverse();
void matrix_trace();
void determinent();
int determinent_solution(int **a,int order);
int ** inverse(int **matrix,int order);

//..............................FUNCTION TO DISPLAY THE MENU FOR THE STRING MODULE..............................

//................................FUNCTION FOR THE SYSTEM TITLE..................................

void header_message()
{
	printf("\n\n\t\t ____________________________________________");
	printf("\n\n\t\t|\tMATHS AND STRING MANIPULATION\t     |");
	printf("\n\t\t ____________________________________________");
}

void string_menu()
{
	char ch,che;
	int count = 0;
	system("cls");
	header_message();

	printf("\n\n\t\t ____________________________________________");
	printf("\n\n\n\t\t\t1. ADD STRINGS \n\n\t\t\t2. DELETE STRING\n\n\t\t\t3. SEARCH CHARACTER\n\n\t\t\t4. REPLACE CHARACTER");
	printf("\n\n\t\t ____________________________________________");
	do{
	
		printf("\n\n\t\tENTER YOUR CHOICE = ");
	
		ch = getch();
	
		if (ch >= 49 && ch <=53)
		{
			printf("%c",ch);
			che = getch();
		}
		if (che==8)
		{
			printf("\b");
			printf(" ");
			printf("\b");
		}
		else if(che == 13)
		{
				count++;

				switch(ch)
				{
				case '1': add_string();
					break;
				case '2': delete_string();
					break;
				case '3': search_character();
					break;
				case '4': replace_character();
					break;
				}
			
		}
	}while(count!=1);
}

//.................................FUNCTION TO DISPLAY THE MENU FOR THE MATRIX..................................

void matrix_menu()
{
	int count = 0;
	char ch, che;
	
	system("cls");
	header_message();
	
	printf("\n\n\t\t ____________________________________________");
	printf("\n\n\n\t\t\t1. MATRIX ADDITION \n\n\t\t\t2. MATRIX SUBTRACTION\n\n\t\t\t3. DETERMINENT OF MATRIX\n\n\t\t\t4. TRACE OF MATRIX\n\n\t\t\t5. INVERSE OF MATRIX\n\n\t\t\t6. MATRIX MULTIPLICATION");
	printf("\n\n\t\t ____________________________________________");
	do{
	
		printf("\n\n\t\tENTER YOUR CHOICE = ");
	
		ch = getch();
	
		if (ch >= 49 && ch <=55)
		{
			printf("%c",ch);
			che = getch();
		}
		if (che==8)
		{
			printf("\b");
			printf(" ");
			printf("\b");
		}
		else if(che == 13)
		{
				count++;

				switch(ch)
				{
				case '1': matrix_addition();
					break;
				case '2': matrix_subtraction();
					break;
				case '3': determinent();
					break;
				case '4': matrix_trace();
					break;
				case '5': matrix_inverse();
					break;
				case '6': multiplication();
					break;
				}
		}
		
	}while(count!=1);

}


//.....................FUNCTION TO DISPLAY THE MENU FOR THE CONVERSION MODULE......................

void conversions_menu()
{
	char ch,che;
	int count = 0;
	system("cls");
	header_message();
	printf("\n\n\t\t ____________________________________________");
	printf("\n\n\n\t\t\t1. BINARY TO DECIMAL \n\n\t\t\t2. DECIMAL TO BINARY\n\n\t\t\t3. BINARY ADDITION\n\n\t\t\t4. BINARY SUBTRACTION");
	printf("\n\n\t\t ____________________________________________");
	do{
	
		printf("\n\n\t\tENTER YOUR CHOICE = ");
	
		ch = getch();
	
		if (ch >= 49 && ch <=53)
	
		{
		
			printf("%c",ch);
			che = getch();
		if (che==8)
		{
			printf("\b");
			printf(" ");
			printf("\b");
		}
		else if(che == 13)
		{
				count++;
				switch(ch)
				{
				case '1': binary_decimal_fun();
					break;
				case '2': decimal_binary_fun();
					break;
				case '3': binary_addition_fun();
					break;
				case '4': binary_subtraction();
					break;
				}
			}
		}
	}while(count!=1);

}
//...........................FUNCTION TO DISPLAY THE MAIN MENU...............................

void main_screen()
{
	char ch,che;
	int count = 0;
	printf("\n\n\t\t ____________________________________________");
	printf("\n\n\n\t\t\t1. CONVERSIONS \n\n\t\t\t2. MATRIX MATHS\n\n\t\t\t3. STRING FUNCTIONS\n\n\t\t\t4. EXIT");
	printf("\n\n\t\t ____________________________________________");
	printf("\n\n\t\tENTER YOUR CHOICE = ");
	do{
	ch = getch();
	if (ch >= 49 && ch <=53)
	{
		printf("%c",ch);
		che = getch();
		if (che==8)
		{
			printf("\b");
			printf(" ");
			printf("\b");
		}
		else if(che == 13)
		{
			count++;

			switch(ch)
			{
			case '1' :	conversions_menu();
				break;
			case '2': matrix_menu();
				break;
			case '3': string_menu();
				break;
			case '4':exit(1);
			}
		}
	
	}
	}while(count != 1);

}

//...........................MAIN FUNCTION FROM WHERE THE EXECUTION OF THE PROGRAM WILL START..........................

void main()
{
	header_message();
	main_screen();
	getch();
}

void decimal_binary_fun()
{
	int binary_number = 0,decimal_number;

	system("cls");
	header_message();
	
	printf("\n\n\n\t\t\t ENTER THE DECIMAL NUMBER - ");
	decimal_number = number_scanning_check();

	binary_number = decimal_binary(decimal_number);

	printf("\n\n    BINARY CONVERSION OF DECIMAL NUMBER %d (BASE 10)IS ----- %d (BASE 2)",decimal_number,binary_number);

	while(getch()!=13)
	{
	}
	conversions_menu();

}

int decimal_binary(int decimal_number)
{
	int binary_number = 0,remain = 0, count = 1;
	
	while(decimal_number != 0)
	{
		remain = decimal_number % 2;
		decimal_number = decimal_number / 2;

		binary_number = binary_number  + remain * count;
		count = count * 10;
	}

	return binary_number;
}

void binary_decimal_fun()
{
	int decimal_number,binary_number;
	system("cls");
	header_message();
	binary_number = binary_number_scanning_check();
	decimal_number = binary_decimal(binary_number);
	
	printf("\n\n    DECIMAL CONVERSION OF BINARY NUMBER %d (BASE 2)IS ----- %d (BASE 10)",binary_number,decimal_number);
	while(getch()!=13)
	{
	}
	
	conversions_menu();

}

int binary_decimal(int binary_number)
{
	int i=0,binary_number_remain,decimal_number = 0;
	
	while(binary_number!=0)
	{
		binary_number_remain = binary_number % 10;
		binary_number = binary_number / 10;

		decimal_number = decimal_number + binary_number_remain * power(2,i);
		i++;
	}

	return decimal_number;

}

void binary_addition_fun()
{
	int binary_number1, binary_number2, binary_number3;

	system("cls");
	header_message();

	binary_number1 = binary_number_scanning_check();
	binary_number2 = binary_number_scanning_check();
	binary_number3 = binary_addition(binary_number1,binary_number2);

	printf("\n\n\n BINARY ADDITION OF NUMBER %d (BASE2) AND %d (BASE 2) IS --- %d (BASE2)",binary_number1,binary_number2,binary_number3);

	while(getch()!=13)
	{
	}

	conversions_menu();

}
int binary_addition(int binary_number1, int binary_number2)
{
	int decimal_number1 ,decimal_number2, decimal_number3, binary_number3;

	decimal_number1 = binary_decimal(binary_number1);
	decimal_number2 = binary_decimal(binary_number2);
	decimal_number3 = decimal_number1 + decimal_number2;
	binary_number3 = decimal_binary(decimal_number3);
	return binary_number3;
}

void binary_subtraction()
{
	int binary_number1, binary_number2, binary_number3, decimal_number1, decimal_number2, decimal_number3, count = 1,flag = 0,remain, new_binary =0;

	system("cls");
	header_message();

	binary_number1 = binary_number_scanning_check();
	binary_number2 = binary_number_scanning_check();
	decimal_number1 = binary_decimal(binary_number1);
	decimal_number2 = binary_decimal(binary_number2);

	if (decimal_number1 >= decimal_number2)
	{
		flag = 0; 
		decimal_number3 = decimal_number1 - decimal_number2;
	}
	else
	{
		flag = 1;
		decimal_number3 = decimal_number2 - decimal_number1;
	}

	binary_number3 = decimal_binary(decimal_number3);
	
	if (flag == 1)
	{
		new_binary = binary_number3;
		binary_number3 = 0;
		
		while(new_binary!=0)
		{
			remain = new_binary % 10;
			new_binary = new_binary / 10;

			if (remain == 0)
			{
				binary_number3 = binary_number3 + 1 * count;
			}
			else
			{
				binary_number3 = binary_number3 + 0 * count;
			}

			count = count  * 10;

		}
		
		binary_number3 = binary_addition(binary_number3,1);
	}

	printf("\n\n\n BINARY SUBTRACTION OF NUMBER %d (BASE2) AND %d (BASE 2) IS --- %d (BASE2)",binary_number1,binary_number2,binary_number3);

	while(getch()!=13)
	{
	}
	conversions_menu();
}

int power(int base, int power)
{
	int number = 1, m;
	if (power == 0)
	{
		return 1;
	}
	else
	{
		for (m = 1; m <= power; m++)
		{
			number = number * base ;
		}

	}
	return number;
}

int number_scanning_check()											// Function to check whether the number entered is positive integer or not
{
	int number, temp = 1, n,i;
	char temp_number[12];											// "temp" will act as flag to store either 0 and 1 for looping purpose

	do{
		if(temp == 0)										
		{
			printf("\n\n\t   DO ENTER THE VALUE AGAIN\t = ");
		}
		
		number=0;
	
		gets(temp_number);									// Scanning the number through gets function defined in <string.h> library
		fflush(stdin);
	
		if(stricmp(temp_number,"")==0)
		{
			printf("\a\n\t\t  ERROR: FIELD CAN'T BE SKIPPED");
			temp=0;
		}
		else
		{
			n=0;
			for(i=0;i<strlen(temp_number);i++)
			{
				if(temp_number[i]>=48 && temp_number[i]<=57)		// 48-57 are the ASCII values of numbers 0-9
				{
					n++;
					switch (temp_number[i])						
					{
				
					case '0': number = number*10 + 0; break;
					case '1': number = number*10 + 1; break;
					case '2': number = number*10 + 2; break;
					case '3': number = number*10 + 3; break;
					case '4': number = number*10 + 4; break;
					case '5': number = number*10 + 5; break;
					case '6': number = number*10 + 6; break;
					case '7': number = number*10 + 7; break;
					case '8': number = number*10 + 8; break;
					case '9': number = number*10 + 9; break;
				
					}
				}
			}
	
			if(n!=strlen(temp_number))
			{
				printf("\a\n\t\t  ERROR: ENTER POSITIVE INTEGERS ONLY");
				temp=0;
			}
			else
			{
				temp=1;
			}
		}
	}while(temp!=1);

	return number;
}

int binary_number_scanning_check()
{
	char temp_number[16],ch;
	int i = 0,j=0,count = 1,number=0;
	
	printf("\n\n\n\t\t    ENTER THE BINARY NUMBER = ");
	do
	{
		ch = getch();

		if (ch == 13)
		{
			break;
		}
		if (ch == 49 ||ch == 48)
		{
			printf("%c",ch);
			temp_number[i] = ch;
			i++;
		}
		else if((ch == 8) && (i != 0))
		{
			printf("\b");
			printf(" ");
			printf("\b");
			if (i!=0)
			{
				i--;
			}
			continue;
		}
		
	}while(i != 16);

	printf("\n\n");

	j = i;
	i = 0;

	while( i < j)
	{
		if (temp_number[i] == 48)
		{
			number = number * 10 + 0;
		}
		else if (temp_number[i] == 49)
		{
			number = number * 10 + 1 ;
		}
		
		i++;
		
	}

	return number;
	
}

//...............................MATRIX MATHS MAIPULATION....................................
void matrix_addition()
{
	int first_matrix[6][6], second_matrix[6][6], result_matrix[6][6],row[2],coloumn[2],count = 0,i,j;

	do{

		system("cls");
		header_message();
		printf("\n\n\n\t => MAXIMUM ROWS AND COLOUMN ALLOWED FOR THE SYSTEM IS 6\n");
		
	
		for(i = 0; i < 2; i++)
		{
			printf("\n  ENTER THE ROW FOR MATRIX %d - ",i+1);
			row[i] = number_scanning_check();
			printf("\n  ENTER THE COL FOR MATRIX %d - ",i+1);
			coloumn[i] = number_scanning_check();
		}

		if ((row[0] == row[1]) && (coloumn[0]==coloumn[1]))
		{
			count++;
		}
		else
		{
			printf("\n MATRIX ADDITION NOT POSSIBLE- ROWS AND COLOUMNS NEED TO BE SAME");
		}
		if(row[0] > 6 || coloumn[0] > 6 || row[1] > 6 || coloumn[1] > 6)
		{
			printf("\n\tSIZE OF MATRIX CANNOT INCREASE 6 ");
			count --;
		}
		

		printf("\n\n    PRESS ENTER TO CONTINUE................");
		while(getch()!=13);

	}while(count!=1);

	system("cls");
		header_message();
		printf("\n\n");

	for(i=0;i<row[0];i++)
	{
		for(j = 0 ; j < coloumn[0];j++)
		{
			printf("\n  FIRST_MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			scanf("%d",&first_matrix[i][j]);
		}
	}

	system("cls");
		header_message();
		printf("\n\n");

	for(i=0;i < row[1];i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("\n  SECOND_MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			scanf("%d",&second_matrix[i][j]);
		}
	}

	system("cls");
		header_message();

	for(i=0;i < row[1] ; i++)
	{
		for(j = 0 ; j < coloumn[1] ; j++)
		{
			result_matrix[i][j] = first_matrix[i][j] + second_matrix[i][j];
		}
	}
	printf("\n\n");

	printf("  FIRST MATRIX\t||\t  SECOND MATRIX\t||\t  RESULT MATRIX\n\n");

	for(i=0; i < row[1]; i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("    %d",first_matrix[i][j]);
			
		}
		printf("   ||   ");
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("    %d",second_matrix[i][j]);
			
		}
		printf("   ||   ");
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("    %d",result_matrix[i][j]);
			
		}
		printf("\n\n");
	}

	while(getch()!=13)
	{

	}

	matrix_menu();

	getch();

}

void matrix_subtraction()
{
	int first_matrix[6][6], second_matrix[6][6], result_matrix[6][6],row[2],coloumn[2],count = 0,i,j;

	do{

		system("cls");
		header_message();
		printf("\n\n\t => MAXIMUM ROWS AND COLOUMN ALLOWED FOR THE SYSTEM IS 6\n");
		
	
		for(i = 0; i < 2; i++)
		{
			printf("\n  ENTER THE ROW FOR MATRIX %d - ",i+1);
			row[i] = number_scanning_check();
			printf("\n  ENTER THE COL FOR MATRIX %d - ",i+1);
			coloumn[i] = number_scanning_check();
		}

		if ((row[0] == row[1]) && (coloumn[0]==coloumn[1]))
		{
			count++;
		}
		else
		{
			printf("\n\n MATRIX SUBTRACTION NOT POSSIBLE- ROWS AND COLOUMNS NEED TO BE SAME");
		}
		if(row[0] > 6 || coloumn[0] > 6 || row[1] > 6 || coloumn[1] > 6)
		{
			printf("\n\tSIZE OF MATRIX CANNOT INCREASE 6 ");
			count --;
		}
		

		printf("\n\n    PRESS ENTER TO CONTINUE................");
		while(getch()!=13);

	}while(count!=1);

	system("cls");
		header_message();

		printf("\n\n");
	for(i=0;i<row[0];i++)
	{
		for(j = 0 ; j < coloumn[0];j++)
		{
			printf("\n  FIRST_MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			first_matrix[i][j] = number_scanning_check();
		}
	}

	system("cls");
	header_message();

	printf("\n\n");

	for(i=0;i < row[1];i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("\n  SECOND_MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			scanf("%d",&second_matrix[i][j]);
		}
	}

	system("cls");
		header_message();

		printf("\n\n");

	for(i=0;i < row[1] ; i++)
	{
		for(j = 0 ; j < coloumn[1] ; j++)
		{
			result_matrix[i][j] = first_matrix[i][j] - second_matrix[i][j];
		}
	}
	printf("\n\n");

	printf("  FIRST MATRIX\t||\t  SECOND MATRIX\t||\t  RESULT MATRIX\n\n");

	for(i=0; i < row[1]; i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("    %d",first_matrix[i][j]);
			
		}
		printf("   ||   ");
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("    %d",second_matrix[i][j]);
			
		}
		printf("   ||   ");
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("    %d",result_matrix[i][j]);
			
		}
		printf("\n\n");
	}
	while(getch()!=13)
	{

	}

	matrix_menu();

	getch();
}

void multiplication()
{
	int first_matrix[6][6], second_matrix[6][6], result_matrix[6][6],row[2],coloumn[2],count = 0,i,j,sum = 0,k;

	do{

		system("cls");
		header_message();
		printf("\n\n\t => MAXIMUM ROWS AND COLOUMN ALLOWED FOR THE SYSTEM IS 6\n");
		
	
		for(i = 0; i < 2; i++)
		{
			printf("\n  ENTER THE ROW FOR MATRIX %d - ",i+1);
			row[i] = number_scanning_check();
			printf("\n  ENTER THE COL FOR MATRIX %d - ",i+1);
			coloumn[i] = number_scanning_check();
		}

		if (coloumn[0] == row[1])
		{
			count++;
		}
		else
		{
			printf("\n\n MULTIPLICATION NOT POSSIBLE - ROW_FIRST MATRIX MUST BE EQUAL TO COLOUMNS OF SECOND MATRIX");
		}
		if(row[0] > 6 || coloumn[0] > 6 || row[1] > 6 || coloumn[1] > 6)
		{
			printf("\n\n\tSIZE OF MATRIX CANNOT INCREASE 6 ");
			count --;
		}
		

		printf("\n\n    PRESS ENTER TO CONTINUE................");
		while(getch()!=13);

	}while(count!=1);

	system("cls");
	header_message();

	printf("\n\n");
	for(i=0;i<row[0];i++)
	{
		for(j = 0 ; j < coloumn[0];j++)
		{
			printf("\n  FIRST_MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			first_matrix[i][j] = number_scanning_check();
		}
	}

	system("cls");
	header_message();
	printf("\n\n");
	
	for(i=0;i < row[1];i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("\n  SECOND_MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			scanf("%d",&second_matrix[i][j]);
		}
	}

	system("cls");
	header_message();
	printf("\n\n");
	
	for(i = 0;i < row[0];i++)
		{
			for(j = 0; j < coloumn[1] ; j++)
			{
           		result_matrix[i][j] = 0;
			
				for(k = 0; k < row[0] ; k++)
				{				
					result_matrix[i][j] = result_matrix[i][j] + first_matrix [i][k] * second_matrix[k][j];
				}

			}
		}

	printf("\n\n");
	printf("\t\tMATRIX 1\n\n");

	for(i=0; i < row[0]; i++)
	{
		for(j = 0 ; j < coloumn[0];j++)
		{
			printf("\t%d",first_matrix[i][j]);
		}

		printf("\n\n");
	}
	printf("\n\n");

	printf("\t\tMATRIX 2\n\n");
	
	for(i=0; i < row[1]; i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("\t%d",second_matrix[i][j]);
		}

		printf("\n\n");
	}
	
	printf("\n\n");
	printf("\t\tRESULT MATRIX\n\n");
	
	for(i=0; i < row[0]; i++)
	{
		for(j = 0 ; j < coloumn[1];j++)
		{
			printf("\t%d",result_matrix[i][j]);
		}

		printf("\n\n");
	}
	while(getch()!=13)
	{

	}

	matrix_menu();

	getch();
}

void matrix_trace()
{
	int sum = 0, matrix[6][6],row,order,flag = 0,i,j;

	do{

		system("cls");
		header_message();
		printf("\n\n  => TRACE CAN BE CALCULATED ONLY FOR THE SQUARE MATRIX \n\n\t\t\t(I.E. ROWS AND COLOUMN NEED TO BE SAME)");

		printf("\n\nENTER THE ORDER OF THE MATRIX - ");	
		order = number_scanning_check();

		if (order > 6)
		{
			printf("\n\tSIZE OF MATRIX CANNOT INCREASE 6 ");
		}
		else
		{
			flag++;
		}
	}while(flag!=1);

	for(i = 0 ; i < order ; i++)
	{
		for(j = 0 ; j < order;j++)
		{
			printf("\n  MATRIX [%d][%d] ELEMENT - ",i+1,j+1);
			matrix[i][j] = number_scanning_check();
		}
	}

	for(i = 0; i < order ; i++)
	{
		sum = sum + matrix[i][i];
		
	}

	system("cls");
	header_message();
	printf("\n\n");
	printf("\n   MATRIX ");
	
	for(i=0; i < order; i++)
	{
		for(j = 0 ; j < order;j++)
		{
			printf("\t%d",matrix[i][j]);
		}

		printf("\n\n");
	}

	printf("TRACE OF MATRIX = %d", sum);
	while(getch()!=13)
	{

	}

	matrix_menu();
	getch();
}

void determinent()
{

	int deter, order, **matrix, i, j, flag=0;
	
	matrix = malloc(6 * sizeof(int *));
	
	for(i=0 ; i < 6; i++)
	{
		matrix[i] = malloc(6 * sizeof(int *));
	}


	system("cls");
	header_message();
	printf("\n\n");

	do{
	
		printf("\n\nENTER THE ORDER OF THE MATRIX - ");	
		order = number_scanning_check();

		if (order > 6)
		{
			printf("\n\tSIZE OF MATRIX CANNOT INCREASE 6 ");
		}
		else
		{
			flag++;
		}
	}while(flag!=1);

	
	for(i=0;i<order;i++)
	{
		for(j=0;j<order;j++)
		{
			printf("\nMATRIX[%d][%d] ELEMENT - ",i+1,j+1);
			
			matrix[i][j] = number_scanning_check();			//......scanning the elements of the matrix.........
		}
	}

	deter = determinent_solution(matrix,order);

	system("cls");
	header_message();
	printf("\n\n");

	for(i=0; i < order; i++)
	{
		for(j = 0 ; j < order;j++)
		{
			printf("\t%d",matrix[i][j]);
		}

		printf("\n\n");
	}

	printf("\n\n\t  DETERMINENT OF MATRIX = %d",deter);
	getch();
}

int determinent_solution(int **a,int order)
{

	int **temp,i, j, k = 0, b = 0, deter = 0, coloumn_position, minor_value = 0;
	
	temp = malloc((5) * sizeof(int *));

	for(i = 0; i < 5; i++)
	{
		temp[i] = malloc(5 * sizeof(int *));
	}
	
	for(i=0;i<5;i++)
	{
		for(j=0;j<5;j++)
		{
			temp[i][j]=0;
		}
	}
	
	if (order == 1)
	{
		return a[0][0];
	}
	else if (order == 2)
	{
		return (a[0][0] * a[1][1] - a[1][0] * a[0][1]) ;
	}
	else 
	{
		for(coloumn_position = 0; coloumn_position < order; coloumn_position++)
		{
			k = 0, b = 0;
			
			for(i = 1; i < order; i++)
				{
					for(j = 0; j < order; j++)
					{
						if(coloumn_position != j)
						{
							temp[k][b] = a[i][j]; 
							b++;
						}
	 				}
					k++;

					b = 0;
				}

			minor_value =  determinent_solution(temp,order - 1);
			
			deter = deter + power(-1,coloumn_position) * a[0][coloumn_position] * minor_value;

		}
	}
	free(temp);

	return deter;

}

void matrix_inverse()
{
	int deter, order, **matrix,i,j,**inverse_matrix,**temp,flag = 0;

	matrix = malloc(6 * sizeof(int *));
	
	for(i=0 ; i < 6; i++)
	{
		matrix[i] = malloc(6 * sizeof(int *));
	}

	temp = malloc(6 * sizeof(int *));
	
	for(i=0 ; i < 6; i++)
	{
		temp[i] = malloc(6 * sizeof(int *));
	}

	system("cls");
	header_message();
	do{
	
		printf("\n\nENTER THE ORDER OF THE MATRIX - ");	
		order = number_scanning_check();

		if (order > 6)
		{
			printf("\n\tSIZE OF MATRIX CANNOT INCREASE 6 ");
		}
		else
		{
			flag++;
		}
	}while(flag!=1);

	
	for(i=0;i < order;i++)
	{
		for(j=0; j < order;j++)
		{
			printf("\nMATRIX[%d][%d] ELEMENT - ",i+1,j+1);
			
			matrix[i][j] = number_scanning_check();			//.....SCANNING THE VALIDATED NUMBER INTO THE MATRIX........
		}
	}

	deter = determinent_solution(matrix,order);
	
	printf("%d",deter);
	inverse_matrix = inverse(matrix,order);
	
	for(i = 0 ; i < order ; i++)
	{
		for(j = 0 ; j < order ; j++)
		{
			temp[i][j] = inverse_matrix[j][i];
		}
	}

	system("cls");
	header_message();
	printf("\n\n");
	printf("\tMATRIX\n\n");


	for(i=0; i < order; i++)
	{
		for(j = 0 ; j < order;j++)
		{
			printf("\t%d",matrix[i][j]);
		}
		
		printf("\n\n");
	}

	
	
	if(deter!=0)
	{
		printf("\n\n\t\tINVERSE\n\n");
		for(i=0;i<order;i++)
		{
		
			for(j = 0 ; j < order;j++)
			{
				printf("\t%d/%d",temp[i][j],deter);
			}
			printf("\n\n");
		}
	}
	else
	{
		printf("\n  AS DETERMINENT IF 0 SO INVERSE NOT POSSIBLE EVERY ELEMENT WILL BE INFINITY");
	}
	while(getch()!=13)
	{
	}
	matrix_menu();
	
	getch();
}

int ** inverse(int **matrix,int order)
{
	int **temp, i, j, row_temp = 0, col_temp = 0, deter = 0, coloumn_pos,row_pos, minor_value = 0, **cofactor_matrix;
		
	cofactor_matrix = malloc(6 * sizeof(int *));
	
	for(i=0 ; i < 6; i++)
	{
		cofactor_matrix[i] = malloc(6 * sizeof(int *));
	}
	temp = malloc(5 * sizeof(int *));
	
	for(i=0 ; i < 5; i++)
	{
		temp[i] = malloc(5 * sizeof(int *));
	}

	if (order == 1)		
	{
		return matrix[0][0];
	}
	else if (order == 2)
	{
		cofactor_matrix[0][0] = matrix[1][1];
		cofactor_matrix[0][1] = - matrix[1][0];
		cofactor_matrix[1][0] = - matrix[0][1];
		cofactor_matrix[1][1] = matrix[0][0];

		return cofactor_matrix;
	}
	else 
	{
		for(row_pos = 0; row_pos < order ; row_pos++)
		{
			
			for(coloumn_pos = 0; coloumn_pos < order; coloumn_pos++)
		
			{
			
			row_temp = 0, col_temp = 0;
			
			for(i = 0; i < order ; i++)
				{
					for(j = 0; j < order; j++)
					{
						if((row_pos!=i) && (coloumn_pos != j))	// CHECKING FOR THE ROW AND COLOUMN
						{
							temp[row_temp][col_temp] = matrix[i][j]; 
							col_temp++;
						}
 				}
				
				if (col_temp != 0)
				{
					row_temp++;
				}
					col_temp = 0;
			}
			
			minor_value = determinent_solution(temp,order-1);
			cofactor_matrix [row_pos][coloumn_pos] = power(-1,row_pos) * power(-1,coloumn_pos)* minor_value; 
		}
	}
	return cofactor_matrix;
	}
}

//...............................STRING MAIPULATION....................................

void add_string()
{
	char main_string[16], add_string[16], result_string[32],ch,che;
	int i = 0,j=0, count = 0;
	system("cls");
	header_message();

	printf("\n\n\t\t______________________________________________");

	printf("\n\n\t\t  ENTER THE ORGINAL STRING   --> ");

	while(i!=15)
	{
		ch = getch();

		if (ch == 13 && i!=0)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i != 0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
				
			}
		}
		else if(ch != 13)
		{
			printf("%c",ch);
			main_string[i] = ch;
			i++;
		}

	}

	main_string[i] = '\0';

	printf("\n\n\t\t  ENTER THE STRING TO INSERT --> ");
	i = 0;

	while(i!=15)
	{
		ch = getch();

		if (ch == 13 && i !=0)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i != 0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
				
			}
		}
		else if(ch != 13)
		{
			printf("%c",ch);
			add_string[i] = ch;
			i++;
		}
	}

	add_string[i] = '\0';
	printf("\n\n\t\t______________________________________________");
	

	printf("\n\n\t\t  PRESS 1 TO CONCATENATE STRING AT FRONT END \n\n\t\t  PRESS 2 TO CONCATENATE STRING AT REAR END\n");
	printf("\n\t\t______________________________________________");
	printf("\n\n\t\t  ENTER THE CHOICE  --> ");
	
	do
	{
		ch = getch();
		
		if ((ch == 49)||(ch == 50))
		{
			printf("%c",ch);
		}
		che = getch();

		if(che == 8)
		{
			printf("\b");
			printf(" ");
			printf("\b");
		}

		i = 0;
		
		if (ch == 49)
		{
			while(i != (strlen(add_string)))
			{
				result_string[i] = add_string[i];
				
				i++;
			}

			j = 0;

			while(j!=strlen(main_string))
			{
				result_string[i] = main_string[j];
				j++;
				i++;
			}
			
			count++;
		}
		else if(ch == 50)
		{
			while(i!=strlen(main_string))
			{
				result_string[i] = main_string[i];
				i++;
			}

			j = 0;

			while(j!=strlen(add_string))
			{
				result_string[i] = add_string[j];
				j++;
				i++;
			}
			
			count++;

		}
		result_string[i] = '\0';
	}while(count!=1);
	printf("\n\t\t______________________________________________");

	printf("\n\n\t\t  RESULTANT STRING  -->  ");
	puts(result_string);
	printf("\n\t\t______________________________________________");

	while(getch()!=13)
	{
	}
	string_menu();
	getch();
}

void delete_string()
{
	int i = 0, count=0,j;
	char ch,che;
	system("cls");
	header_message();
	printf("\n\n\t____________________________________________________________________");
	
	printf("\n\n\t  PROVIDE THE STRING TO BE REMOVED FROM  --  ");
	while(i!=SIZE)
	{
		ch = getch();

		if (ch == 13 && i != 0)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i!=0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
			}
		}
		else if (ch != 13)
		{
			printf("%c",ch);
			node.temp_string[i] = ch;
			i++;
		}
	}

	node.temp_string[i] = '\0';
	
	printf("\n\t___________________________________________________________________");
	printf("\n\n\t\t\t\tREMOVE STRING FROM -  ");
	printf("\n\n\t\t      1. FRONT END\n\n\t\t      2. REAR  END");
	printf("\n\n\t\tENTER YOUR CHOICE - ");
	do 
	{
		ch = getch();

		if (ch == 49 || ch == 50)
		{
			printf("%c",ch);
		}
		che = getch();

		if (che == 8)
		{
			printf("\b");
			printf(" ");
			printf("\b");
		}
		else
		{
			if (ch == 49 || ch == 50)
			{
				count++;
			}
		}
		
	}while(count!=1);

		if (ch == 49)
		{
			
			printf("\n\n\t  FRONT END REMOVAL - ");
			printf("\n\n   NUMBER OF CHARCTERS TO BE REMOVED -- ");
			node.char_count = number_scanning_check();		

			if (node.char_count > strlen(node.temp_string))
			{
				printf("\n\n\t\t LENGTH TO BE REMOVED EXCEEDS STRING LENGTH");
			}
			else
			{
				printf("\n\n   NEW STRING -- ");
				for(i = node.char_count; node.temp_string[i] != '\0'; i++)
				{
					printf("%c",node.temp_string[i]);
				}
			}
		}
		else if(ch == 50)
		{
			
			printf("\n\n\t  REAR END REMOVAL - ");
			printf("\n\n   NUMBER OF CHARCTERS TO BE REMOVED -- ");
			node.char_count = number_scanning_check();

			
			if (node.char_count > strlen(node.temp_string))
			{
				printf("\n\n\t\t LENGTH TO BE REMOVED EXCEEDS STRING LENGTH");
			}
			else
			{
				printf("\n\n   NEW STRING -- ");
				
				j = strlen(node.temp_string) - node.char_count;

				for(i = 0; i < j ; i++)
				{
					printf("%c",node.temp_string[i]);
				}
			}
		
		}
		while(getch()!=13)
	{
	}
	string_menu();
	getch();
}

void replace_character()
{

  char first_string[SIZE], remove_string[SIZE], new_string[SIZE], temp[SIZE],ch;
  int first_string_len, remove_string_len, new_string_len, i, j, placefound, k, c = 0, length = 0;

  system("cls");
	header_message();
	
	printf("\n\n\t ENTER THE STRING - ");
	
	i = 0;

	while(i!=SIZE)
	{
		ch = getch();

		if (ch == 13 && i != 0)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i!=0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
			}
		}
		else if(ch != 13)
		{
			printf("%c",ch);
			first_string[i] = ch;
			i++;
		}
	}

	first_string[i] = '\0';

	first_string_len = check_length(first_string);

	printf("\n\n\t ENTER THE STRING TO BE CHECKED - ");
	

	i = 0;
		while(i!=SIZE)
	{
		ch = getch();

		if (ch == 13 && i != 0)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i!=0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
			}
		}
		else if(ch!=13)
		{
			printf("%c",ch);
			remove_string[i] = ch;
			i++;
		}
	}

	remove_string[i] = '\0';
	
	remove_string_len = check_length(remove_string);
	
	printf("\n\n\t ENTER THE STRING TO BE ADDED -  ");
	i = 0;
		while(i!=SIZE)
	{
		ch = getch();

		if (ch == 13 && i != 0)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i!=0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
			}
		}
		else if (ch != 13)
		{
			printf("%c",ch);
			new_string[i] = ch;
			i++;
		}
	}

	new_string[i] = '\0';

	new_string_len = check_length(new_string);
	
	for(i=0;i<=first_string_len;i++)
	{
		placefound = 1;

		for(j=0;j<=remove_string_len;j++)

			if(remove_string[j]!=first_string[i+j])
			{
				placefound = 0;

				break;
			}
		if(placefound)
		{
			for(k=0,j=i+remove_string_len+1;j<=first_string_len;j++,k++)
			{
				temp[k] = first_string[j];
			}
			temp[k] = '\0';
			
			for(j=0;j<=new_string_len;j++)
			{
				first_string[i+j] = new_string[j];
			}
			first_string[i+j] = '\0';

			string_cat(first_string,temp);

			first_string_len = first_string_len - remove_string_len + new_string_len;

			i = i + j;

		}
	}

	printf("\n\n\t\tRESULTANT STRING --> ");
	puts(first_string);
	
	while(getch()!=13)
	{
	}
	string_menu();
	getch();

}

void string_cat(char temp1_string[SIZE], char temp2_string[SIZE])
{
	int i = 0,length = 0;

	while(temp1_string[length]!='\0')
	{
		length++;
	}

	while(temp2_string[i]!='\0')
	{
		temp1_string[length] = temp2_string[i];
		i++;
		length++;
	}
	
	temp1_string[length] = '\0';
}

void search_character()
{
	int i = 0;
	char ch ;
	system("cls");
	header_message();
	printf("\n\n\t_______________________________________________________________");
	printf("\n\n\tPROVIDE THE STRING TO BE CHECKED IN  --  ");
	
	while(i!=SIZE)
	{
		ch = getch();

		if (ch == 13)
		{
			break;
		}
		
		if (ch == 8)
		{
			if (i!=0)
			{
				printf("\b");
				printf(" ");
				printf("\b");
				i--;
			}
		}
		else
		{
			printf("%c",ch);
			node.temp_string[i] = ch;
			i++;
		}
	}

	node.temp_string[i] = '\0';
	
	node.char_count = 0;

	fflush(stdin);
	printf("\n\n\tPROVIDE THE CHARACTER TO SEARCH      --  ");
	scanf("%c",&ch);

	printf("\n\t_______________________________________________________________\n\n");

	i = 0;

	while(node.temp_string[i] != '\0')
	{
		
		if ((node.temp_string[i]) == ch)
		{
			node.char_count = node.char_count + 1;
			
		}
		i++;

	}
	printf("\n\t\t   THE CHARACTER %c HAS REPEATED %d TIMES.",ch,node.char_count);
	while(getch()!=13)
	{

	}

	string_menu();
	getch();

}

//...............................MATRIX FUNCTIONS..........................................


int check_length(char temp1_string[SIZE])
{
	int length = 0;

	while(temp1_string[length]!='\0')
	{
		length++;
	}

	length--;

	return length;
	
}