Add files via upload

Author: AnikSR

Algebra.c

@@ -0,0 +1,50 @@
+#include "Algebra.h"
+
+extern int r1, r2, *coefficient;
+
+/* Extended Euclid's algorithm to determine the coefficients such that the linear combination produces the gcd. */
+void gcdCoefficient(int r1, int r2, int * coefficient){
+	int r, q, s, t, s1=1, s2=0, t1=0, t2=1;
+
+	/* The first integer have to be the biggest one for this algorithm to work.
+	   So, exchange the integers if the second one is the biggest. */
+
+	while(r!=0){
+		// Determining the reminder and the quotient of this round.
+		r = r1%r2;
+		q = (int)r1/r2;
+		
+		// Determining the coefficient of this round.
+		s = s1 - q*s2;
+		t = t1 - q*t2;
+
+		// Update the input for the next round.
+		r1 = r2;
+		r2 = r;
+
+		s1 = s2;
+		s2 = s;
+
+		t1 = t2;
+		t2 = t;
+	}
+
+	coefficient[0] = r1;	// The greatest common divisor.
+	coefficient[1] = s1;	// Coefficient for the first integer.
+	coefficient[2] = t1;	// Coefficient for the second integer.
+}
+
+
+
+/* Good old Euclid's algorithms of determining gcd of two numbers. */
+int gcdEuclid(int r1, int r2){
+	int r;
+
+	while(r!=0){
+		r = r1%r2;
+		r1 = r2;
+		r2 = r;
+	}
+
+	return r1;
+}

Algebra.h

@@ -0,0 +1,7 @@
+#include<stdio.h>
+
+/* Extended Euclid's algorithm to determine the coefficients such that the linear combination produces the gcd. */
+void EuclidX(int, int, int *);
+
+/* The good old Euclid's algorithms of determining gcd of two numbers. */
+int gcdEuclid(int, int);

EuclidX.c

@@ -2,28 +2,33 @@
 /* Extended Euclid's algorithm to determine the coefficients such that the linear combination produces the gcd. */
 #include<stdio.h>
 
-void gcdCoefficient(int, int, int *);
+void EuclidX(int, int, int *);
 
 int main(void){
 	int num1, num2, temp=0;
 	int coefficient[3] = { 0, 0, 0 };
 
+	puts("\n");
+	puts("This program calculates the gcd and the smallest coefficient satisfying Bezout's identity ps + qt = gcd(p,q)");
+	puts("In the output:");
+	puts("The 's' stands for the coefficient of the first number inserted.");
+	puts("The 't' stands for the coefficient of the second number inserted.");
+	puts("==============================================================================================================");
+
 	printf("Insert two integers: ");
 	scanf("%d %d", &num1, &num2);
 
-	printf("Before: num1 = %d, num2 = %d\n", num1, num2);
 	if(num2>num1){
 		temp = num2;
 		num2 = num1;
 		num1 = temp;
 		temp = 1;
 	}
-	printf("After: num1 = %d, num2 = %d\n", num1, num2);
 
 	getchar();		// Eat up any stray character length input hanging in the stdin.
 	fflush(stdin);	// Flush out any unwanted character in the stdin.
 
-	gcdCoefficient(num1, num2, coefficient);
+	EuclidX(num1, num2, coefficient);
 
 	if(temp == 1){
 		printf("For %d and %d; s = %d, t = %d.\n", num2, num1, coefficient[2], coefficient[1]);
@@ -37,7 +42,7 @@ int main(void){
 }
 
 
-void gcdCoefficient(int r1, int r2, int * coefficient){
+void EuclidX(int r1, int r2, int * coefficient){
 	int r, q, s, t, s1=1, s2=0, t1=0, t2=1;
 
 	/* The first integer have to be the biggest one for this algorithm to work.
@@ -64,6 +69,6 @@ void gcdCoefficient(int r1, int r2, int * coefficient){
 	}
 
 	coefficient[0] = r1;	// The greatest common divisor.
-	coefficient[1] = s1;		// Coefficient for the first integer.
-	coefficient[2] = t1;		// Coefficient for the second integer.
+	coefficient[1] = s1;	// Coefficient for the first integer.
+	coefficient[2] = t1;	// Coefficient for the second integer.
 }

Matrix.c

@@ -0,0 +1,92 @@
+#include "Matrix.h"
+
+/****************************************************************************************
+ * Following three function performs three elementary row operations. 					*
+ * 1. Function		: multiply_rowwide.													*
+ *	  Description	: Multiplies the specified row with a scalar.						*
+ *																						*
+ * 2. Function		: row_exchange.														*
+ *	  Description	: Exchange two rows with one another.								*
+ *																						*
+ * 3. Function		: row_arithmetic.													*
+ *    Description	: Add scalar multiple of one row with another.						*
+ ****************************************************************************************/
+void multiply_rowwide(float *mtrx, int row_num, int row_len, float scalar){
+	for(int i=0; i<row_len; i++)
+		mtrx[icalc(row_num, row_len, i)] *= scalar;
+}
+
+
+void row_arithmetic(float *mtrx, int row_len, int target_row, int add_row, float scalar){
+	for(int i=0; i<row_len; i++){
+		float B = mtrx[icalc(add_row, row_len, i)]*scalar;
+		mtrx[icalc(target_row, row_len, i)] -= B;
+	}
+}
+
+
+void row_exchange(float *mtrx, int row1, int row2, int rowlength){
+	float temp = 0;
+	
+	for(int i=0; i<rowlength; i++){
+		temp = mtrx[icalc(row1, rowlength, i)];
+		mtrx[icalc(row1, rowlength, i)] = mtrx[icalc(row2, rowlength, i)];
+		mtrx[icalc(row2, rowlength, i)] = temp;
+	}
+}
+
+
+/* Combining all three elementary row operation for Gaus-Jordn elemination. */
+void Gaus_Jordan(float *mtrx, int row_len, int column_len){
+	int rank = min(row_len, column_len);
+
+	for(int i=0; i<rank; i++){
+		// If the leading element of a row is 0, exchange the row with the row bellow it.
+		for(int j=1; mtrx[icalc(i, row_len, i)] == 0 || i+j<column_len; j++)
+			row_exchange(mtrx, i, i+j, row_len);
+
+		// If the leading element is not 1, then divide the row with the leading element.
+		multiply_rowwide(mtrx, i, row_len, 1/mtrx[icalc(i, row_len, i)]);
+
+		// Multiply the current row with the leading element of subsequent rows and substracts it from subsequent rows.
+		for(int j=0; j<column_len; j++)
+			if(i != j)
+				row_arithmetic(mtrx, row_len, j, i, mtrx[icalc(j, row_len, i)]);
+	}
+}
+
+
+/*************************************************************
+ * Function Name:	Index calcultor.						 *
+ * Description	:	Matrix can be adequately represented by  *
+ *					2d arrays. But referencing 2d arrays is  *
+ *					quarky in C. So rather matrix are here   *
+ *					represented by 1d array. Hence the index *
+ *					calculated manually.					 *
+ *************************************************************/
+int icalc(int row_number, int row_length, int member_number){
+	return row_number*row_length+member_number;
+}
+
+
+/*  Rank of a matrix is the highest number of linearly independent vectors
+	that can be formed from the rows/columns of a matrix. However, rank of
+	the input matrix is taken as the minimal of the number of row and the
+	number of column of this matrix. This huristic will cause erronious
+	result for some inputs as the rank of a matrix can be equal of less than
+	the number determined here. */
+int min(int num1, int num2){
+	if(num1 < num2)
+		return num1;
+	
+	return num2;
+}
+
+
+void print_matrix(float *mtrx, int rowlen, int columnlen){
+	for(int i=0; i<columnlen; i++){
+		for(int j=0; j<rowlen; j++)
+			printf("\t%f", mtrx[icalc(i, rowlen, j)]);
+		puts("");
+	}
+}

Matrix.h

@@ -0,0 +1,60 @@
+
+#include<stdio.h>
+
+/* Following three function performs three elementary row operations. 					*/
+/****************************************************************************************
+ * 1. Function		: multiply_rowwide.													*
+ *	  Description	: Multiplies the specified row with a scalar.						*
+ ****************************************************************************************/
+// Prototype:
+void multiply_rowwide(float *, int, int, float);
+
+/****************************************************************************************
+ * 2. Function		: row_exchange.														*
+ *	  Description	: Exchange two rows with one another.								*
+ ****************************************************************************************/
+// Prototype:
+void row_exchange(float *, int, int, int);
+
+ /***************************************************************************************
+ * 3. Function		: row_arithmetic.													*
+ *    Description	: Add scalar multiple of one row with another.						*
+ ****************************************************************************************/
+//Prototype:
+void row_arithmetic(float *, int, int, int, float);
+
+
+
+/* Bringing the elementary row operations together to performa Gaus-Jordan Elimination.*/
+void Gaus_Jordan(float *, int, int);
+
+
+
+
+/* Auxilary functions:
+ * These functions perform operations like calculating the index, determining the rank, inputing matrices or printing them etc. */
+
+/*************************************************************
+ * Function Name:	Index calcultor.						 *
+ * Description	:	Matrix can be adeuately represented by   *
+ *					2d arrays. But referencing 2d arrays is  *
+ *					quarky in C. So rather matrix are here   *
+ *					represented by 1d array. Hence the index *
+ *					calculated manually.					 *
+ *************************************************************/
+//Prototype:
+int icalc(int, int, int);
+
+
+/*  Rank of a matrix is the highest number of linearly independent vectors
+	that can be formed from the rows/columns of a matrix. However, rank of
+	the input matrix is taken as the minimal of the number of row and the
+	number of column of this matrix. This huristic will cause erronious
+	result for some inputs as the rank of a matrix can be equal of less than
+	the number determined here. */
+// Prototype:
+int min(int, int);
+
+
+// Print a matrix as a table of numbers.
+void print_matrix(float *, int, int);