implement delta matrix in rust and move to use incidence matrix

CMakeLists.txt

@@ -53,7 +53,7 @@ set(FALKORDB_OBJECTS $<TARGET_OBJECTS:falkordb>)
 find_package(OpenSSL)
 
 lists_from_env(GRAPHBLAS LIBXXHASH RAX LIBCYPHER_PARSER REDISEARCH_LIBS UTF8PROC ONIGURUMA FalkorDBRS)
-set(FALKORDB_LIBS ${GRAPHBLAS} ${LIBXXHASH} ${RAX} ${LIBCYPHER_PARSER} ${REDISEARCH_LIBS} ${UTF8PROC} ${ONIGURUMA} ${FalkorDBRS} OpenSSL::SSL)
+set(FALKORDB_LIBS ${FalkorDBRS} ${GRAPHBLAS} ${LIBXXHASH} ${RAX} ${LIBCYPHER_PARSER} ${REDISEARCH_LIBS} ${UTF8PROC} ${ONIGURUMA} OpenSSL::SSL)
 
 target_link_options(falkordb PRIVATE ${CMAKE_LD_FLAGS_LIST} ${CMAKE_SO_LD_FLAGS_LIST})
 target_link_libraries(falkordb PRIVATE ${FALKORDB_LIBS} ${CMAKE_LD_LIBS})

src/algorithms/all_neighbors.c

@@ -16,19 +16,19 @@ static void _AllNeighborsCtx_CollectNeighbors
 ) {
 	ctx->current_level++;
 	if(ctx->current_level == array_len(ctx->levels)) {
-		RG_MatrixTupleIter iter = {0};
-		RG_MatrixTupleIter_AttachRange(&iter, ctx->M, id, id);
+		Delta_MatrixTupleIter iter = {0};
+		Delta_MatrixTupleIter_AttachRange(&iter, ctx->M, id, id);
 		array_append(ctx->levels, iter);
 	} else {
-		RG_MatrixTupleIter_iterate_row(&ctx->levels[ctx->current_level], id);
+		Delta_MatrixTupleIter_iterate_row(&ctx->levels[ctx->current_level], id);
 	}
 }
 
 void AllNeighborsCtx_Reset
 (
 	AllNeighborsCtx *ctx,  // all neighbors context to reset
 	EntityID src,          // source node from which to traverse
-	RG_Matrix M,           // matrix describing connections
+	Delta_Matrix M,        // matrix describing connections
 	uint minLen,           // minimum traversal depth
 	uint maxLen            // maximum traversal depth
 ) {
@@ -53,15 +53,15 @@ void AllNeighborsCtx_Reset
 	ctx->visited_nodes = HashTableCreate(&def_dt);
 
 	// dummy iterator at level 0
-	array_append(ctx->levels, (RG_MatrixTupleIter) {0});
+	array_append(ctx->levels, (Delta_MatrixTupleIter) {0});
 }
 
 AllNeighborsCtx *AllNeighborsCtx_New
 (
-	EntityID src,  // source node from which to traverse
-	RG_Matrix M,   // matrix describing connections
-	uint minLen,   // minimum traversal depth
-	uint maxLen    // maximum traversal depth
+	EntityID src,    // source node from which to traverse
+	Delta_Matrix M,  // matrix describing connections
+	uint minLen,     // minimum traversal depth
+	uint maxLen      // maximum traversal depth
 ) {
 	ASSERT(M   != NULL);
 	ASSERT(src != INVALID_ENTITY_ID);
@@ -72,14 +72,14 @@ AllNeighborsCtx *AllNeighborsCtx_New
 	ctx->src            = src;
 	ctx->minLen         = minLen;
 	ctx->maxLen         = maxLen;
-	ctx->levels         = array_new(RG_MatrixTupleIter, 1);
+	ctx->levels         = array_new(Delta_MatrixTupleIter, 1);
 	ctx->visited        = array_new(EntityID, 1);
 	ctx->first_pull     = true;
 	ctx->current_level  = 0;
 	ctx->visited_nodes  = HashTableCreate(&def_dt);
 
 	// Dummy iterator at level 0
-	array_append(ctx->levels, (RG_MatrixTupleIter) {0});
+	array_append(ctx->levels, (Delta_MatrixTupleIter) {0});
 
 	return ctx;
 }
@@ -112,10 +112,10 @@ EntityID AllNeighborsCtx_NextNeighbor
 
 	while(ctx->current_level > 0) {
 		ASSERT(ctx->current_level < array_len(ctx->levels));
-		RG_MatrixTupleIter *it = &ctx->levels[ctx->current_level];
+		Delta_MatrixTupleIter *it = &ctx->levels[ctx->current_level];
 
 		GrB_Index dest_id;
-		GrB_Info info = RG_MatrixTupleIter_next_UINT64(it, NULL, &dest_id, NULL);
+		GrB_Info info = Delta_MatrixTupleIter_next_BOOL(it, NULL, &dest_id, NULL);
 
 		if(info == GxB_EXHAUSTED) {
 			// backtrack
@@ -160,7 +160,7 @@ void AllNeighborsCtx_Free
 
 	uint count = array_len(ctx->levels);
 	for (uint i = 0; i < count; i++) {
-		RG_MatrixTupleIter_detach(ctx->levels + i);
+		Delta_MatrixTupleIter_detach(ctx->levels + i);
 	}
 	array_free(ctx->levels);
 	array_free(ctx->visited);

src/algorithms/all_neighbors.h

@@ -8,8 +8,8 @@
 
 #include "../../deps/GraphBLAS/Include/GraphBLAS.h"
 #include "../util/dict.h"
-#include "../graph/rg_matrix/rg_matrix.h"
-#include "../graph/rg_matrix/rg_matrix_iter.h"
+#include "../graph/delta_matrix/delta_matrix.h"
+#include "../graph/delta_matrix/delta_matrix_iter.h"
 #include "../graph/entities/node.h"
 
 // performs iterative DFS from 'src'
@@ -22,32 +22,32 @@
 // current path
 
 typedef struct {
-	EntityID src;                  // traverse begin here
-	RG_Matrix M;                   // adjacency matrix
-	uint minLen;                   // minimum required depth
-	uint maxLen;                   // maximum allowed depth
-	int current_level;             // current depth
-	bool first_pull;               // first call to Next
-	EntityID *visited;             // visited nodes
-	RG_MatrixTupleIter *levels;    // array of neighbors iterator
-	dict *visited_nodes;           // visited nodes
+	EntityID src;                   // traverse begin here
+	Delta_Matrix M;                 // adjacency matrix
+	uint minLen;                    // minimum required depth
+	uint maxLen;                    // maximum allowed depth
+	int current_level;              // current depth
+	bool first_pull;                // first call to Next
+	EntityID *visited;              // visited nodes
+	Delta_MatrixTupleIter *levels;  // array of neighbors iterator
+	dict *visited_nodes;            // visited nodes
 } AllNeighborsCtx;
 
 void AllNeighborsCtx_Reset
 (
 	AllNeighborsCtx *ctx,  // all neighbors context to reset
 	EntityID src,          // source node from which to traverse
-	RG_Matrix M,           // matrix describing connections
+	Delta_Matrix M,        // matrix describing connections
 	uint minLen,           // minimum traversal depth
 	uint maxLen            // maximum traversal depth
 );
 
 AllNeighborsCtx *AllNeighborsCtx_New
 (
-	EntityID src,  // source node from which to traverse
-	RG_Matrix M,   // matrix describing connections
-	uint minLen,   // minimum traversal depth
-	uint maxLen    // maximum traversal depth
+	EntityID src,    // source node from which to traverse
+	Delta_Matrix M,  // matrix describing connections
+	uint minLen,     // minimum traversal depth
+	uint maxLen      // maximum traversal depth
 );
 
 // produce next reachable destination node

src/arithmetic/algebraic_expression.h

@@ -9,7 +9,7 @@
 #include "../graph/graph.h"
 #include "../graph/query_graph.h"
 
-static RG_Matrix IDENTITY_MATRIX = (RG_Matrix)0x31032017;  // identity matrix
+static Delta_Matrix IDENTITY_MATRIX = (Delta_Matrix)0x31032017;  // identity matrix
 
 // Matrix, vector operations
 typedef enum {
@@ -40,7 +40,7 @@ struct AlgebraicExpression {
 			const char *dest;           // alias given to operand's columns
 			const char *edge;           // alias given to operand (edge)
 			const char *label;          // label attached to matrix
-			RG_Matrix matrix;           // matrix
+			Delta_Matrix matrix;        // matrix
 		} operand;
 		struct {
 			AL_EXP_OP op;                   // operation: `*`,`+`,`transpose`
@@ -72,7 +72,7 @@ AlgebraicExpression *AlgebraicExpression_NewOperation
 // Create a new AlgebraicExpression operand node.
 AlgebraicExpression *AlgebraicExpression_NewOperand
 (
-	RG_Matrix mat,      // Matrix.
+	Delta_Matrix mat,   // Matrix.
 	bool diagonal,      // Is operand a diagonal matrix?
 	const char *src,    // Operand row domain (src node).
 	const char *dest,   // Operand column domain (destination node).
@@ -185,31 +185,31 @@ AlgebraicExpression *AlgebraicExpression_RemoveDest
 void AlgebraicExpression_MultiplyToTheLeft
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 );
 
 // Multiply expression to the right by operand
 // (exp) * m
 void AlgebraicExpression_MultiplyToTheRight
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 );
 
 // Add expression to the left by operand
 // m + (exp)
 void AlgebraicExpression_AddToTheLeft
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 );
 
 // Add expression to the right by operand
 // (exp) + m
 void AlgebraicExpression_AddToTheRight
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 );
 
 // Transpose expression
@@ -220,10 +220,10 @@ void AlgebraicExpression_Transpose
 );
 
 // Evaluate expression tree.
-RG_Matrix AlgebraicExpression_Eval
+Delta_Matrix AlgebraicExpression_Eval
 (
 	const AlgebraicExpression *exp, // Root node
-	RG_Matrix res                   // Result output
+	Delta_Matrix res                // Result output
 );
 
 // locates operand based on row,column domain and edge or label

src/arithmetic/algebraic_expression/algebraic_expression.c

@@ -171,7 +171,7 @@ AlgebraicExpression *AlgebraicExpression_NewOperation
 // Create a new AlgebraicExpression operand node
 AlgebraicExpression *AlgebraicExpression_NewOperand
 (
-	RG_Matrix mat,      // Matrix
+	Delta_Matrix mat,      // Matrix
 	bool diagonal,      // Is operand a diagonal matrix?
 	const char *src,    // Operand row domain (src node)
 	const char *dest,   // Operand column domain (destination node)
@@ -490,7 +490,7 @@ AlgebraicExpression *AlgebraicExpression_RemoveDest
 void AlgebraicExpression_MultiplyToTheLeft
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 ) {
 	ASSERT(root && m);
 	AlgebraicExpression *rhs = *root;
@@ -508,7 +508,7 @@ void AlgebraicExpression_MultiplyToTheLeft
 void AlgebraicExpression_MultiplyToTheRight
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 ) {
 	ASSERT(root && m);
 	AlgebraicExpression *lhs = *root;
@@ -526,7 +526,7 @@ void AlgebraicExpression_MultiplyToTheRight
 void AlgebraicExpression_AddToTheLeft
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 ) {
 	ASSERT(root && m);
 	AlgebraicExpression *rhs = *root;
@@ -545,7 +545,7 @@ void AlgebraicExpression_AddToTheLeft
 void AlgebraicExpression_AddToTheRight
 (
 	AlgebraicExpression **root,
-	RG_Matrix m
+	Delta_Matrix m
 ) {
 	ASSERT(root && m);
 	AlgebraicExpression *lhs = *root;

src/arithmetic/algebraic_expression/algebraic_expression_add.c

@@ -8,10 +8,10 @@
 #include "../../query_ctx.h"
 #include "../algebraic_expression.h"
 
-RG_Matrix _Eval_Add
+Delta_Matrix _Eval_Add
 (
 	const AlgebraicExpression *exp,
-	RG_Matrix res
+	Delta_Matrix res
 ) {
 	ASSERT(exp);
 	ASSERT(AlgebraicExpression_ChildCount(exp) > 1);
@@ -22,9 +22,9 @@
 	GrB_Index ncols;                   // number of columns of operand
 
 	bool        res_in_use  =  false;  //  can we use `res` for intermediate evaluation
-	RG_Matrix   A           =  NULL;   //  left operand
-	RG_Matrix   B           =  NULL;   //  right operand
-	RG_Matrix   inter       =  NULL;   //  intermediate matrix
+	Delta_Matrix   A           =  NULL;   //  left operand
+	Delta_Matrix   B           =  NULL;   //  right operand
+	Delta_Matrix   inter       =  NULL;   //  intermediate matrix
 
 	// get left and right operands
 	AlgebraicExpression *left = CHILD_AT(exp, 0);
@@ -45,9 +45,9 @@
 	if(right->type == AL_OPERATION) {
 		if(res_in_use) {
 			// `res` is in use, create an additional matrix
-			RG_Matrix_nrows(&nrows, res);
-			RG_Matrix_ncols(&ncols, res);
-			info = RG_Matrix_new(&inter, GrB_BOOL, nrows, ncols);
+			Delta_Matrix_nrows(&nrows, res);
+			Delta_Matrix_ncols(&ncols, res);
+			info = Delta_Matrix_new(&inter, GrB_BOOL, nrows, ncols, false);
 			ASSERT(info == GrB_SUCCESS);
 			B = AlgebraicExpression_Eval(right, inter);
 		} else {
@@ -62,7 +62,7 @@
 	// perform addition
 	//--------------------------------------------------------------------------
 
-	info = RG_eWiseAdd(res, GxB_ANY_PAIR_BOOL, A, B);
+	info = Delta_eWiseAdd(res, GxB_ANY_PAIR_BOOL, A, B);
 	ASSERT(info == GrB_SUCCESS);
 
 	uint child_count = AlgebraicExpression_ChildCount(exp);
@@ -76,21 +76,21 @@
 			// 'right' represents either + or * operation
 			if(inter == NULL) {
 				// can't use `res`, use an intermidate matrix
-				RG_Matrix_nrows(&nrows, res);
-				RG_Matrix_ncols(&ncols, res);
-				info = RG_Matrix_new(&inter, GrB_BOOL, nrows, ncols);
+				Delta_Matrix_nrows(&nrows, res);
+				Delta_Matrix_ncols(&ncols, res);
+				info = Delta_Matrix_new(&inter, GrB_BOOL, nrows, ncols, false);
 				ASSERT(info == GrB_SUCCESS);
 			}
 			AlgebraicExpression_Eval(right, inter);
 			B = inter;
 		}
 
 		// perform addition
-		info = RG_eWiseAdd(res, GxB_ANY_PAIR_BOOL, res, B);
+		info = Delta_eWiseAdd(res, GxB_ANY_PAIR_BOOL, res, B);
 		ASSERT(info == GrB_SUCCESS);
 	}
 
-	if(inter != NULL) RG_Matrix_free(&inter);
+	if(inter != NULL) Delta_Matrix_free(&inter);
 	return res;
 }
 

src/arithmetic/algebraic_expression/algebraic_expression_debug.c

@@ -30,7 +30,7 @@ AlgebraicExpression *_AlgebraicExpression_FromString
 	int len = 0;
 	char *alias;
 	const char *operand;
-	RG_Matrix m;
+	Delta_Matrix m;
 	AlgebraicExpression *op;
 	AlgebraicExpression *rhs;
 	AlgebraicExpression *root = NULL;
@@ -83,7 +83,7 @@ AlgebraicExpression *_AlgebraicExpression_FromString
 
 			m = NULL;
 			if(matrices) {
-				m = (RG_Matrix)raxFind(matrices, (unsigned char *)alias, strlen(alias));
+				m = (Delta_Matrix)raxFind(matrices, (unsigned char *)alias, strlen(alias));
 				ASSERT(m != raxNotFound && "Missing matrix");
 			}
 			root = AlgebraicExpression_NewOperand(m, false, alias, alias, NULL, NULL);