Telodendria/Cytoplasm
Telodendria/Cytoplasm
3
3
Fork 5
Code Issues 17 Pull requests 2 Projects Releases 2 Packages Activity Actions

Add basic Graph API.

Browse source 
This is going to be useful with state resolution and dependency ordering,
both of which will be crutial components of Telodendria.
This commit is contained in:
Jordan Bancino 2023-07-16 01:12:56 +00:00
parent c4ef6d4ddc
commit e592cd8e5c
2 changed files with 522 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

347
src/Graph.c Normal file
View file

@ -0,0 +1,347 @@
/*
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Graph.h>
#include <Memory.h>
#include <string.h>
struct Graph
{
size_t n;
Edge *matrix;
};
Graph *
GraphCreate(size_t n)
{
Graph *g;
if (!n)
{
return NULL;
}
g = Malloc(sizeof(Graph));
if (!g)
{
return NULL;
}
g->n = n;
g->matrix = Malloc((n * n) * sizeof(Edge));
if (!g->matrix)
{
Free(g);
return NULL;
}
memset(g->matrix, 0, (n * n) * sizeof(Edge));
return g;
}
Graph *
GraphCreateWithEdges(size_t n, Edge * matrix)
{
Graph *g = GraphCreate(n);
if (!g)
{
return NULL;
}
memcpy(g->matrix, matrix, (n * n) * sizeof(Edge));
return g;
}
void
GraphFree(Graph * g)
{
if (!g)
{
return;
}
Free(g->matrix);
Free(g);
}
Edge
GraphEdgeGet(Graph * g, Node n1, Node n2)
{
if (n1 >= g->n || n2 >= g->n)
{
return -1;
}
return g->matrix[(g->n * n1) + n2];
}
Edge
GraphEdgeSet(Graph * g, Node n1, Node n2, Edge e)
{
int oldVal;
if (n1 >= g->n || n2 >= g->n)
{
return -1;
}
if (e < 0)
{
return -1;
}
oldVal = g->matrix[(g->n * n1) + n2];
g->matrix[(g->n * n1) + n2] = e;
return oldVal;
}
size_t
GraphCountNodes(Graph * g)
{
return g ? g->n : 0;
}
Node *
GraphBreadthFirstSearch(Graph * G, Node s, size_t * n)
{
Node *visited;
Node *queue;
Node *result;
size_t queueSize;
Node i;
if (!G || !n)
{
return NULL;
}
*n = 0;
result = Malloc(G->n * sizeof(Node));
if (!result)
{
return NULL;
}
if (s >= G->n)
{
Free(result);
return NULL;
}
visited = Malloc(G->n * sizeof(Node));
memset(visited, 0, G->n * sizeof(Node));
queue = Malloc(G->n * sizeof(Node));
queueSize = 0;
visited[s] = 1;
queueSize++;
queue[queueSize - 1] = s;
while (queueSize)
{
s = queue[queueSize - 1];
queueSize--;
result[*n] = s;
(*n)++;
for (i = 0; i < G->n; i++)
{
if (GraphEdgeGet(G, s, i) && !visited[i])
{
visited[i] = 1;
queueSize++;
queue[queueSize - 1] = i;
}
}
}
Free(visited);
Free(queue);
return result;
}
static void
GraphDepthFirstSearchRecursive(Graph * G, Node s, Node * result, size_t * n,
Node * visited)
{
size_t i;
visited[s] = 1;
result[*n] = s;
(*n)++;
for (i = 0; i < G->n; i++)
{
if (GraphEdgeGet(G, s, i) && !visited[i])
{
GraphDepthFirstSearchRecursive(G, i, result, n, visited);
}
}
}
Node *
GraphDepthFirstSearch(Graph * G, Node s, size_t * n)
{
Node *visited;
Node *result;
if (!G || !n)
{
return NULL;
}
result = Malloc(G->n * sizeof(Node));
if (!result)
{
return NULL;
}
*n = 0;
if (s >= G->n)
{
Free(result);
return NULL;
}
visited = Malloc(G->n * sizeof(Node));
memset(visited, 0, G->n * sizeof(Node));
GraphDepthFirstSearchRecursive(G, s, result, n, visited);
Free(visited);
return result;
}
static void
GraphTopologicalSortRecursive(Graph * G, Node s, Node * visited,
Node * stack, size_t * stackSize)
{
size_t i;
visited[s] = 1;
for (i = 0; i < G->n; i++)
{
if (GraphEdgeGet(G, s, i) && !visited[i])
{
GraphTopologicalSortRecursive(G, i, visited, stack, stackSize);
}
}
stack[*stackSize] = s;
(*stackSize)++;
}
Node *
GraphTopologicalSort(Graph * G, size_t * n)
{
Node *visited;
Node *stack;
Node *result;
size_t i;
size_t stackSize;
if (!G || !n)
{
return NULL;
}
*n = 0;
result = Malloc(G->n * sizeof(Node));
if (!result)
{
return NULL;
}
visited = Malloc(G->n * sizeof(Node));
memset(visited, 0, G->n * sizeof(Node));
stack = Malloc(G->n * sizeof(Node));
memset(stack, 0, G->n * sizeof(Node));
stackSize = 0;
for (i = 0; i < G->n; i++)
{
if (!visited[i])
{
GraphTopologicalSortRecursive(G, i, visited, stack, &stackSize);
}
}
Free(visited);
while (stackSize)
{
stackSize--;
result[*n] = stack[stackSize];
(*n)++;
}
Free(stack);
return result;
}
Graph *
GraphTranspose(Graph * G)
{
Graph *T = Malloc(sizeof(Graph));
size_t i, j;
T->n = G->n;
T->matrix = Malloc((G->n * G->n) * sizeof(Edge));
memset(T->matrix, 0, (T->n * T->n) * sizeof(Edge));
for (i = 0; i < G->n; i++)
{
for (j = 0; j < G->n; j++)
{
if (GraphEdgeGet(G, i, j))
{
GraphEdgeSet(T, j, i, GraphEdgeGet(G, i, j));
}
}
}
return T;
}

175
src/include/Graph.h Normal file
View file

@ -0,0 +1,175 @@
/*
* Copyright (C) 2022-2023 Jordan Bancino <@jordan:bancino.net>
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef CYTOPLASM_GRAPH_H
#define CYTOPLASM_GRAPH_H
/***
* @Nm Graph
* @Nd Extremely simple graph, implemented as an adjacency matrix.
* @Dd July 15 2023
*
* .Nm
* is a basic graph data structure originally written for a computer
* science class on data structures and algorithms, in which it
* received full credit. This is an adaptation of the original
* implementation that follows the Cytoplasm style and uses Cytoplasm
* APIs when convenient.
* .P
* .Nm
* stores data in an adjacency matrix, which means the storage
* complexity is O(N^2), where N is the number of vertices (called
* Nodes in this implementation) in the graph. However, this makes the
* algorithms fast and efficient.
* .P
* Nodes are identified by index, so the first node is 0, the second
* is 1, and so on. This data structure does not support storing
* arbitrary data as nodes; rather, the intended use case is to add
* all your node data to an Array, thus giving each node an index,
* and then manipulating the graph with that index. This allows access
* to node data in O(1) time in call cases, and is the most memory
* efficient.
* .P
* .Nm
* can be used to store a variety of types of graphs, although it is
* primarily suited to directed and weighted graphs.
*/
#include <stddef.h>
/**
* The functions provided here operate on an opaque graph structure.
* This structure really just stores a matrix in a contiguous block of
* memory, as well as the number of nodes in the graph, but the
* structure is kept opaque so that it remains internally consistent.
* It also maintains the style of the Cytoplasm library.
*/
typedef struct Graph Graph;
/**
* An Edge is really just a weight, which is easily represented by an
* integer. However, it makes sense to alias this to Edge for clarity,
* both in the documentation and in the implementation.
*/
typedef int Edge;
/**
* A Node is really just a row or column in the matrix, which is easily
* represented by an unsigned integer. However, it makes sense to alias
* this to Node for clarity, both in the documentation and the
* implementation.
*/
typedef size_t Node;
/**
* Create a new graph structure with the given number of vertices.
*/
extern Graph *GraphCreate(size_t);
/**
* Create a new graph data structure with the given number of vertices
* and the given adjacency matrix. The adjacency matrix is copied
* verbatim into the graph data structure without any validation.
*/
extern Graph *GraphCreateWithEdges(size_t, Edge *);
/**
* Free all memory associated with the given graph. Since graphs are
* just a collection of numbers, they do not depend on each other in
* any way.
*/
extern void GraphFree(Graph *);
/**
* Get the weight of the edge connecting the node specified first to
* the node specified second. If this is a directed graph, it does not
* necessarily follow that there is an edge from the node specified
* second to the node specified first. It also does not follow that
* such an edge, if it exists, has the same weight.
* .P
* This function will return -1 if the graph is invalid or either node
* is out of bounds. It will return 0 if there is no such edge from the
* node specified first to the node specified second.
*/
extern Edge GraphEdgeGet(Graph *, Node, Node);
/**
* Set the weight of the edge connecting the node specified first to
* the node specified second. If this is not a directed graph, this
* function will have to be called twice, the second time reversing the
* order of the nodes. To remove the edge, specify a weight of 0.
*/
extern Edge GraphEdgeSet(Graph *, Node, Node, Edge);
/**
* Get the number of nodes in the given graph. This operation is a
* simple memory access that happens in O(1) time.
*/
extern size_t GraphCountNodes(Graph *);
/**
* Perform a breadth-first search on the given graph, starting at the
* specified node. This function returns a list of nodes in the order
* they were touched. The size of the list is stored in the unsigned
* integer pointed to by the last argument.
* .P
* If an error occurs, NULL will be returned. Otherwise, the returned
* pointer should be freed with the Memory API when it is no longer
* needed.
*/
extern Node * GraphBreadthFirstSearch(Graph *, Node, size_t *);
/**
* Perform a depth-first search on the given graph, starting at the
* specified node. This function returns a list of nodes in the order
* they were touched. The size of the list is stored in the unsigned
* integer pointed to by the last argument.
* .P
* If an error occurs, NULL will be returned. Otherwise the returned
* pointer should be freed with the Memory API when it is no longer
* needed.
*/
extern Node *GraphDepthFirstSearch(Graph *, Node, size_t *);
/**
* Perform a topological sort on the given graph. This function returns
* a list of nodes in topological ordering, though note that this is
* probably not the only topological ordering that exists for the
* graph. The size of the list is stored in the unsigned integer
* pointed to by the last argument. It should always be the number of
* nodes in the graph, but is provided for consistency and convenience.
* .P
* If an error occurs, NULL will be returned. Otherwise the returned
* pointer should be freed with the Memory API when it is no longer
* needed.
*/
extern Node *GraphTopologicalSort(Graph *, size_t *);
/**
* Transpose the given graph, returning a brand new graph that is the
* result of the transposition.
*/
extern Graph * GraphTranspose(Graph *);
#endif /* CYTOPLASM_GRAPH_H */