Unit Testing prototypes

Author: Judahmeek

.gitignore

@@ -1,3 +1,9 @@
+# All test files
+test.*
+
+# All executable files
+*.exe
+
 # Windows image file caches
 Thumbs.db
 ehthumbs.db

C/Plaindrome/Deprecated/PlaindromeMisc.h

@@ -0,0 +1 @@
+//Deprecated

C/Plaindrome/Plaindrome.c

@@ -46,7 +46,7 @@ int main() {
 	const short SIZE = 26;
 	const short zerothSIZE = SIZE - 1;
     short freq[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
-    short c,size = 0;
+    short i,c,size = 0;
 
     while(c != '\n'){ //input anagram of palindrome
     	c = getchar();
@@ -58,10 +58,10 @@ int main() {
     }
 
     short odd = 0, freqSize = 0; //test for palindrome qualities
-    for(c = 0; c<SIZE; ++c){
-        if(freq[c] > 0){
+    for(i = 0; i<SIZE; ++i){
+        if(freq[i] > 0){
         	++freqSize;
-        	if(freq[c] % 2 != 0)
+        	if(freq[i] % 2 != 0)
         		++odd;
 		}
     }
@@ -72,15 +72,24 @@ int main() {
     	reversedHeapsort(freq, SIZE);
 
     	short tscs = 0; //tscs stands for total state changing swaps
-    	for(c = 0; c < freqSize; ++ c){
-    		tscs += freq[c] * (size - freq[c]);
+    	for(i = 0; i < freqSize; ++i){
+    		tscs += freq[i] * (size - freq[i]);
 		}
 		tscs /= 2;
 
-    	printf("Total states: %d\n", fact(size)/arrayFact(freq, freqSize, 0));
+		int totalStates = fact(size)/arrayFact(freq, freqSize, 0);
+		int posSwaps = size * (size - 1) / 2;
+		
+    	printf("Total states: %d\n", totalStates);
     	printf("Total state changing swaps: %d\n", tscs);
-    	printf("All possible swaps per state: %d\n", size * (size - 1) / 2);
+    	printf("All possible swaps per state: %d\n", posSwaps);
+    	
+		double** MarkovMatrix;
+		MarkovMatrix  = (double**)calloc(sizeof(double*) * totalStates);
+		MarkovMatrix[0] = (double*)calloc(sizeof(double) * totalStates * totalStates); // rows * columns
+		
+		InitializeMatrix(freq, freqSize, stateSize, MarkovMatrix[i], totalStates, i, tscs);
 	}
 
-    return 0; //Todo List: string->step, state matrix initialization, matrix inversion, estimated step calculation: https://en.wikipedia.org/wiki/Absorbing_Markov_chain#Fundamental_matrix
+    return 0; //Todo List: matrix inversion, estimated step calculation: https://en.wikipedia.org/wiki/Absorbing_Markov_chain#Fundamental_matrix
 }

C/Plaindrome/PlaindromeMisc.h

@@ -0,0 +1,21 @@
+short shortArrayCompare (const short x[], const short y[], short size){
+	short i;
+	for(i = 0; i < size; ++i){
+		if(x[i] > y[i])
+			return 1;
+		if(x[i] < y[i])
+			return -1;
+	}
+	return 0;
+};
+
+short intArrayCompare (const int x[], const int y[], short size){
+	short i;
+	for(i = 0; i < size; ++i){
+		if(x[i] > y[i])
+			return 1;
+		if(x[i] < y[i])
+			return -1;
+	}
+	return 0;
+};

C/Plaindrome/ReversedHeapsort.h C/Plaindrome/ReversedHeapsort.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include "arrayCompare.c"
+
+int main() {
+	{
+	short x[] = {3, 2, 2};
+	short y[] = {3, 2, 2};
+	short arraySize = 3;
+	
+	if(!shortArrayCompare(x, y, arraySize))
+		puts("Short Arrays: {3, 2, 2} == {3, 2, 2} : Passed");
+	else
+		puts("Short Arrays: {3, 2, 2} == {3, 2, 2} : Failed");
+	}
+	
+	{
+	int x[] = {3, 2, 2};
+	int y[] = {3, 2, 2};
+	short arraySize = 3;
+	
+	if(!intArrayCompare(x, y, arraySize))
+		puts("Int Arrays: {3, 2, 2} == {3, 2, 2} : Passed");
+	else
+		puts("Int Arrays: {3, 2, 2} == {3, 2, 2} : Failed");
+	}
+	
+	return 0;
+}

C/Plaindrome/arrayCompare.c

@@ -0,0 +1,10 @@
+#include "Factorial.c"
+
+int arrayFactorial(const short x[], short size, short startingIndex, short minus){ //~7/1-17:00 returns sum of each element's factorial O(N)
+	short i = startingIndex;
+	int total = factorial(x[i++] - minus);
+	while(i < size){
+		total *= factorial(x[i++]);
+	}
+	return total;
+};

C/Plaindrome/arrayCompareTest.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include "arrayFactorial.c"
+
+int main() {
+	short array[] = {2, 3, 2};
+	short arraySize = 3;
+	short startingIndex = 0;
+	short minus = 1;
+	if(arrayFactorial(array, arraySize, startingIndex, minus) == 12)
+		puts("arrayFactorial({2, 3, 2}, arraySize: 3, startingIndex: 0, minus: 1) == 12 : Passed");
+	else
+		puts("arrayFactorial({2, 3, 2}, arraySize: 3, startingIndex: 0, minus: 1) == 12 : Failed");
+	return 0;
+}

C/Plaindrome/arrayFactorial.c

@@ -0,0 +1,8 @@
+short arraySum (const short x[], short size){
+	int total = 0;
+	short i;
+	for(i = 0; i < size; ++i){
+		total += x[i];
+	}
+	return total;
+};

C/Plaindrome/arrayFactorialTest.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include "arraySum.c"
+
+int main() {
+	short array[] = {2, 3, 2};
+	short arraySize = 3;
+	if(arraySum(array, arraySize) == 7)
+		puts("arraySum(array: {2, 3, 2}, arraySize: 3) == 7 : Passed");
+	else
+		puts("arraySum(array: {2, 3, 2}, arraySize: 3) == 7 : Failed");
+	return 0;
+}

C/Plaindrome/arraySum.c

@@ -0,0 +1,8 @@
+int factorial(short x){
+	int y = 1;
+	while(x > 1){
+		y *= x;
+		--x;
+	}
+	return y;
+};

C/Plaindrome/arraySumTest.c

@@ -0,0 +1,10 @@
+#include <stdio.h>
+#include "Factorial.c"
+
+int main() {
+	if(factorial(4) == 24)
+		puts("factorial(4) == 24 : Passed");
+	else
+		puts("factorial(4) == 24 : Failed");
+	return 0;
+}

C/Plaindrome/factorial.c

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+void printShortArray (const char* x, const short y[], short size){
+	fputs(x, stdout);
+	short i;
+	for(i = 0; i < size; ++i)
+        printf("%d ", y[i]);
+    puts("");
+};
+
+void printIntArray (const char* x, const int y[], short size){
+	fputs(x, stdout);
+	short i;
+	for(i = 0; i < size; ++i)
+        printf("%d ", y[i]);
+    puts("");
+};

C/Plaindrome/factorialTest.c

@@ -0,0 +1,9 @@
+#include "printArray.c"
+
+void main(){
+	short x[] = {0, -1, 2};
+	int y[] = {3, -4, 5};
+	
+	printShortArray("x: ", x, 3);
+	printIntArray("y: ", y, 3);
+}

C/Plaindrome/printArray.c

@@ -0,0 +1,27 @@
+#include "arrayFactorial.c"
+
+/*creates an array that shows the number of steps required to promote a letter in the same digit.
+Example: [a, a, b] has the signature of [2, 1] because promoting a[0] requires going through both combinations of a[1] and a[2] while promoting a[1] merely requires switching a[1] and a[2].*/
+void promotionSignature (const short freq[], short freqSize, int result[], short resultSize, short startingIndex){
+	short i, j = 0, k = 0;
+	while(freq[j] == 0){
+			++j;
+	}
+	
+	short remainingDigits = resultSize - startingIndex;
+	
+	for(i = 0; i < startingIndex; ++i){
+		result[i] = -1;
+	}
+	for(; i < resultSize; ++i){
+		result[i] = factorial(remainingDigits) / arrayFactorial(freq, freqSize, j, k);
+		if(!result[i])
+			++result[i];
+		++k;
+		if(k == freq[j]){
+			++j;
+			k = 0;
+		}
+		--remainingDigits;
+	}
+};