Initial commit

Author: Erik Mudrak

README.md

@@ -0,0 +1,10 @@
+Topological Sort In 4 Families
+
+Implementation of Kahn's topological sort algorithm in the following families and programming languages:
+
+Functional - Lisp, run with clisp
+Procedural - C, run with gcc
+Object-Oriented - Java, run with javac 
+Logical - Prolog, run with SWI-Prolog
+
+These programs serve as an exploration of four distinctive approaches to solving problems with code. Conceptual mastery of the families of programming languages allows me to choose the right tool to elegantly solve the problem at hand on an development project. Slinging code in each of these diametrically different languages in the span of a few months has reinforced my ability to quickly pick up and utilize a new language and development environment. 

c/Datatype.h

@@ -0,0 +1,22 @@
+// Datatype.h
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// Declares datatypes STRING, EDGE, and GRAPH
+
+#ifndef DATATYPE_H
+#define DATATYPE_H
+
+#include <stdio.h>
+#include <string.h>
+
+#define MAXGRAPHSIZE 200
+#define SENTINEL "BAD HOMBRE"
+
+#define MAXCHARSIZE 50
+typedef char STRING[MAXCHARSIZE];
+
+typedef struct {STRING startNode, endNode;} EDGE;
+
+typedef EDGE GRAPH[MAXGRAPHSIZE]; 
+
+#endif

c/g1.txt

@@ -0,0 +1,9 @@
+a d 
+b d
+b e
+c e
+c h 
+d f
+d g
+d h
+e h

c/graph.c

@@ -0,0 +1,67 @@
+// graph.c
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// graph function implementations
+
+#include "graph.h"
+
+// readGraph: 
+// Reads input file graph in to graph datatype 
+void readGraph (FILE *f, STRING fileName, EDGE *g) {
+	// Throw main fn's file reading code in here
+	int size = 0;
+
+	// Open file and retrieve graph information from it until the end:
+	f = fopen(fileName, "r");
+	if (f == NULL) {
+		printf("File failed to open.");
+	}
+
+	// Step through the file, if we reach the end and the position returned by ftell is 0, the file is empty
+	/// SOURCE: https://www.tutorialspoint.com/c_standard_library/c_function_ftell.htm
+	fseek(f, 0, SEEK_END);
+	if (ftell(f) == 0) {
+		printf("Cannot sort: The graph is empty.\n");
+	} else {
+		// Start back at the beginning of the file and read nodes into graph
+		fseek(f, 0, SEEK_SET);
+		int i = 0;
+		while (!feof(f)) {
+			fscanf(f, "%s %s", g[i].startNode, g[i].endNode);
+			i++;
+		} 
+		size = i;
+	}
+	fclose(f);
+
+	// insert a sentinel at the end of the inputted graph:
+	strcpy(g[size+1].startNode, SENTINEL);
+	strcpy(g[size+1].endNode, SENTINEL);
+}
+
+// removeEdge:
+// Takes in graph g and position i
+// Removes the entire edge at i from the graph
+void removeEdge (int i, EDGE *g) {
+	int j;
+	for (j=i; notSentinel(g[j].endNode); j++) {
+		// Remove the element by putting the next element in its place, until the end of the array is reached
+		strcpy(g[j].startNode, g[j+1].startNode);
+		strcpy(g[j].endNode, g[j+1].endNode);
+	}
+}
+
+/// noIncomingEdges: 
+//	Takes in an element, array, and size 
+// 	Loops through the array in search of the element.
+//	Returns 1 if the node has no incoming edges, 0 if it does have incoming edges
+int noIncomingEdges (STRING element, EDGE *g) {
+	int i;
+	// loop and compare while neither node of the graph's edge is the sentinel
+	for (i=0; notSentinel(g[i].startNode) && notSentinel(g[i].endNode); i++) {
+		if (!strcmp(element, g[i].endNode)) {	
+			return 0;
+		}
+	}	
+	return 1;
+}

c/graph.h

@@ -0,0 +1,28 @@
+// graph.h
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// graph datatype and associated function declarations
+
+#ifndef GRAPH_H
+#define GRAPH_H
+
+#include "Datatype.h"
+
+FILE *graphFile;
+
+// readGraph: 
+// Reads input file graph in to graph datatype 
+void readGraph (FILE *f, STRING fileName, EDGE *g);
+
+// removeEdge:
+// Takes in graph g and position i
+// Removes the entire edge at i from the graph
+void removeEdge (int i, EDGE *g);
+
+/// noIncomingEdges: 
+//	Takes in an element, array, and size 
+// 	Loops through the array in search of the element.
+//	Returns 1 if the node has no incoming edges, 0 if it does have incoming edges
+int noIncomingEdges (STRING element, EDGE *g);
+
+#endif

c/makefile

@@ -0,0 +1,15 @@
+# makefile
+# Erik Mudrak, Fall 2016
+# Principles of Programming Languages
+# topological sort program 
+
+sort: sort.o set.o graph.o
+	gcc -o sort sort.o set.o graph.o
+sort.o: sort.c sort.h set.h graph.h Datatype.h
+	gcc -c sort.c 
+set.o: set.c set.h graph.h Datatype.h
+	gcc -c set.c 
+graph.o: graph.c graph.h Datatype.h
+	gcc -c graph.c
+clean: 
+	rm *.o

c/set.c

@@ -0,0 +1,74 @@
+// set.h
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// set function implementations
+
+#include "set.h"
+
+// notSentinel:
+// Checks if element is equivalent to sentinel and returns 0 if true 
+int notSentinel (STRING element) {
+	return strcmp(element, SENTINEL);
+}
+
+// noDupes:
+// Takes in element and array
+// Returns 1 if the element is already in the array
+int noDupes (STRING element, STRING *a) {
+	int flag = 1;
+	int i = 0;
+	for (i=0; notSentinel(a[i]); i++) {
+		if (!strcmp(element, a[i])) {
+			flag = 0;
+		}
+	}	
+	return flag;
+}
+
+// insertAtEnd:
+// Takes in element and array
+// Inserts element right before the sentinel, aka the end of the list
+void insertAtEnd (STRING element, STRING *a) {
+	// printf("\tPassing in %s for insertion\n", element);
+	int i;
+	for (i=0; notSentinel(a[i]); i++) {
+		// Takes us to the end of the array
+	}
+	strcpy(a[i+1], SENTINEL);
+	strcpy(a[i], element);
+}
+
+// removeElement:
+// Takes in an element and array, removing the element from the array
+void removeNodeN (STRING *a) {
+	// printf("\tPassing in %s for removal\n", element);
+	int j;
+	for (j=0; notSentinel(a[j]); j++) {
+		// Remove the element by putting the next element in its place, until the end of the array is reached
+		strcpy(a[j], a[j+1]);
+	}
+}
+
+// printSet: 
+// takes in set array and prints out all of its elements
+void printSet(STRING *a) {
+	int i;
+	printf("The sorted contents of set L are:\n");
+	for (i=0; notSentinel(a[i]); i++) {
+		printf("%s, ", a[i]);
+	}
+	printf("\n");
+}
+
+/// getS:
+// Takes in (empty) setS and graph and creates set S,
+// 	by looping through the startNode of each edge, providing a duplicate-free set of all nodes with no incoming edges
+void getS (STRING *set, EDGE *g) {
+	int setIndex = 0; 
+	int i;
+	for (i=0; notSentinel(g[i].startNode) && notSentinel(g[i].endNode); i++) {
+		if (noIncomingEdges(g[i].startNode, g) && noDupes(g[i].startNode, set)) {
+			insertAtEnd(g[i].startNode, set);		// add the node element to S
+		}
+	}
+}

c/set.h

@@ -0,0 +1,35 @@
+// set.h
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// setL and setS datatypes and associated function declarations
+
+#ifndef SET_H
+#define SET_H
+
+#include "Datatype.h"
+//#include "graph.h"
+
+
+// notSentinel:
+// Checks if element is equivalent to sentinel and returns 0 if true 
+int notSentinel (STRING element);
+
+// insertAtEnd:
+// Takes in element and array
+// Inserts element right before the sentinel, aka the end of the list
+void insertAtEnd (STRING element, STRING *a);
+
+// removeElement:
+// Takes in an element and array, removing the element from the array
+void removeNodeN (STRING *a);
+
+// printSet: 
+// takes in set array and prints out all of its elements
+void printSet(STRING *a);
+
+/// getS:
+// Takes in (empty) setS and graph and creates set S,
+// 	by looping through the startNode of each edge, providing a duplicate-free set of all nodes with no incoming edges
+void getS (STRING *set, EDGE *g);
+
+#endif

c/sort.c

@@ -0,0 +1,84 @@
+// sort.c
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// Main program. Sorts a direct acyclic graph in topological order.
+// Use 'make' to compile and link 
+// Use './sort fileName.txt' to run and sort
+
+	//// The Algorithm:
+	// L ← Empty list that will contain the sorted elements
+	// S ← Set of all nodes with no incoming edges
+	// while S is non-empty do
+	//     remove a node n from S
+	//     add n to tail of L
+	//     for each node m with an edge e from n to m do
+	//         remove edge e from the graph
+	//         if m has no other incoming edges then
+	//             insert m into S
+	// if graph has edges then
+	//     return error (graph has at least one cycle)
+	// else 
+	//     return L (a topologically sorted order)
+
+#include "sort.h"
+
+STRING setL[MAXGRAPHSIZE] = {SENTINEL};		// Empty set that will contain the sorted elements
+STRING setS[MAXGRAPHSIZE] = {SENTINEL};		// Set of all nodes with no incoming edges 
+
+//// MAIN FUNCTION ////
+int main (int argc, char **argv) 
+{
+	STRING graphName;
+	strcpy(graphName, argv[1]);
+	readGraph(graphFile, graphName, graph);
+
+	// get set S: all nodes with no incoming edges
+	getS(setS, graph);
+
+
+	int i = 0;
+	int j;
+	STRING nodeN, nodeM;
+	STRING first;
+	strcpy(first, graph[i].startNode);
+
+	// Increment through array while the current element does not equal the SENTINEL
+	while (notSentinel(setS[i])) { 
+	
+		strcpy(nodeN, setS[i]); 
+		removeNodeN(setS);
+		insertAtEnd(nodeN, setL);
+
+		// loops through every edge of the graph, checking if the current node and node N match
+		for (j=0; notSentinel(graph[j].startNode); j++) {
+
+			if (!strcmp(nodeN, graph[j].startNode)) {
+				strcpy(nodeM, graph[j].endNode);
+
+				// They're equal? Remove that edge from the graph, and decrement j so that we don't skip edges
+				removeEdge(j, graph);
+				j--;
+
+				if (noIncomingEdges(nodeM, graph)) {
+					insertAtEnd(nodeM, setS);
+				}
+			}
+		}
+	}
+
+	// Check if the graph has edges, if so then it is cyclic
+	for (i = 0; notSentinel(graph[i].startNode); i++) {
+		strcpy(nodeN, graph[i].startNode);
+		if (strcmp("", nodeN)) {
+			// We know it is cyclic if nodeN HAS incoming edge(s)
+			if (!noIncomingEdges(nodeN, graph)) {
+				printf("Error. Graph is cyclic.\n");
+				return 0;	
+			}
+		}
+	}
+	// We made it to the end of the program:
+	// return L, the topologically sorted set
+	printSet(setL);
+}
+

c/sort.h

@@ -0,0 +1,17 @@
+// sort.h
+// Erik Mudrak
+// Principles of Programming Languages - Fall 2016
+// Main header. Sorts a direct acyclic graph in topological order.
+// Includes sort datatypes and function declarations
+
+#ifndef SORT_H
+#define SORT_H
+
+#include "Datatype.h"
+#include "graph.h"
+#include "set.h"
+
+GRAPH graph = {SENTINEL};
+
+#endif
+