@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/algebraic/GraphBLAS.hpp

@@ -0,0 +1,323 @@
+/*
+ * GraphBLAS.hpp
+ *
+ *  Created on: May 31, 2016
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_ALGEBRAIC_GRAPH_BLAS_HPP_
+#define NETWORKIT_ALGEBRAIC_GRAPH_BLAS_HPP_
+
+#include <limits>
+#include <networkit/algebraic/AlgebraicGlobals.hpp>
+#include <networkit/algebraic/Semirings.hpp>
+#include <networkit/algebraic/SparseAccumulator.hpp>
+#include <networkit/algebraic/Vector.hpp>
+
+/**
+ * @ingroup algebraic
+ * Implements the GraphBLAS interface. For more information visit https://graphblas.org.
+ */
+namespace GraphBLAS {
+
+// ****************************************************
+// 						Operations
+// ****************************************************
+
+/**
+ * Computes binOp(A(i,j), B(i,j)) for all i,j element-wise. Note that the dimensions of
+ * @a A and @a B must coincide and that the zero must be the same.
+ * @param A
+ * @param B
+ * @param binOp
+ * @return The resulting matrix.
+ */
+template <class SemiRing, class Matrix, typename L>
+Matrix eWiseBinOp(const Matrix &A, const Matrix &B, L binOp) {
+    assert(A.numberOfRows() == B.numberOfRows() && A.numberOfColumns() == B.numberOfColumns());
+    assert(A.getZero() == B.getZero() && A.getZero() == SemiRing::zero());
+
+    std::vector<int64_t> columnPointer(A.numberOfColumns(), -1);
+    std::vector<double> Arow(A.numberOfColumns(), SemiRing::zero());
+    std::vector<double> Brow(A.numberOfColumns(), SemiRing::zero());
+
+    std::vector<NetworKit::Triplet> triplets;
+
+    for (NetworKit::index i = 0; i < A.numberOfRows(); ++i) {
+        NetworKit::index listHead = 0;
+        NetworKit::count nnz = 0;
+
+        // search for nonZeros in matrix A
+        A.forNonZeroElementsInRow(i, [&](NetworKit::index j, double value) {
+            Arow[j] = value;
+
+            columnPointer[j] = listHead;
+            listHead = j;
+            nnz++;
+        });
+
+        // search for nonZeros in matrix B
+        B.forNonZeroElementsInRow(i, [&](NetworKit::index j, double value) {
+            Brow[j] = value;
+
+            if (columnPointer[j] == -1) { // matrix A does not have a nonZero entry in column j
+                columnPointer[j] = listHead;
+                listHead = j;
+                nnz++;
+            }
+        });
+
+        // apply operator on the found nonZeros in A and B
+        for (NetworKit::count k = 0; k < nnz; ++k) {
+            double value = binOp(Arow[listHead], Brow[listHead]);
+            if (value != SemiRing::zero()) {
+                triplets.push_back({i, listHead, value});
+            }
+
+            NetworKit::index temp = listHead;
+            listHead = columnPointer[listHead];
+
+            // reset for next row
+            columnPointer[temp] = -1;
+            Arow[temp] = SemiRing::zero();
+            Brow[temp] = SemiRing::zero();
+        }
+
+        nnz = 0;
+    }
+
+    return Matrix(A.numberOfRows(), A.numberOfColumns(), triplets, A.getZero());
+}
+
+/**
+ * Computes the matrix-matrix multiplication of @a A and @a B. Note that
+ * A.numberOfColumns() must be equal to B.numberOfRows() and the zero elements
+ * must be the same. The default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param B
+ * @return The result of the multiplication A * B.
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+Matrix MxM(const Matrix &A, const Matrix &B) {
+    assert(A.numberOfColumns() == B.numberOfRows());
+    assert(A.getZero() == SemiRing::zero() && B.getZero() == SemiRing::zero());
+
+    std::vector<NetworKit::Triplet> triplets;
+    NetworKit::SparseAccumulator spa(B.numberOfRows());
+    for (NetworKit::index i = 0; i < A.numberOfRows(); ++i) {
+        A.forNonZeroElementsInRow(i, [&](NetworKit::index k, double w1) {
+            B.forNonZeroElementsInRow(k, [&](NetworKit::index j, double w2) {
+                spa.scatter(SemiRing::mult(w1, w2), j, *SemiRing::add);
+            });
+        });
+
+        spa.gather([&](NetworKit::index i, NetworKit::index j, double value) {
+            triplets.push_back({i, j, value});
+        });
+
+        spa.increaseRow();
+    }
+
+    return Matrix(A.numberOfRows(), B.numberOfColumns(), triplets, A.getZero());
+}
+
+/**
+ * Computes the matrix-matrix multiplication of @a A and @a B and adds it to @a C where
+ * the add operation is that of the specified Semiring (i.e. C(i,j) = SemiRing::add(C(i,j),
+ * (A*B)(i,j))). The default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param B
+ * @param C
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+void MxM(const Matrix &A, const Matrix &B, Matrix &C) {
+    assert(A.numberOfColumns() == B.numberOfRows() && A.numberOfRows() == C.numberOfRows()
+           && B.numberOfColumns() == C.numberOfColumns());
+    assert(A.getZero() == SemiRing::zero() && B.getZero() == SemiRing::zero()
+           && C.getZero() == SemiRing::zero());
+
+    std::vector<NetworKit::Triplet> triplets;
+    NetworKit::SparseAccumulator spa(B.numberOfRows());
+    for (NetworKit::index i = 0; i < A.numberOfRows(); ++i) {
+        A.forNonZeroElementsInRow(i, [&](NetworKit::index k, double w1) {
+            B.forNonZeroElementsInRow(k, [&](NetworKit::index j, double w2) {
+                spa.scatter(SemiRing::mult(w1, w2), j, *SemiRing::add);
+            });
+        });
+
+        spa.gather([&](NetworKit::index i, NetworKit::index j, double value) {
+            triplets.push_back({i, j, value});
+        });
+
+        spa.increaseRow();
+    }
+
+    Matrix temp(A.numberOfRows(), B.numberOfRows(), triplets, A.getZero());
+    C = eWiseBinOp<SemiRing, Matrix>(C, temp, *SemiRing::add);
+}
+
+/**
+ * Computes the matrix-matrix multiplication of @a A and @a B and adds it to @a C where
+ * the add operation is specified by the binary function @a accum (i.e. C(i,j) = accum(C(i,j),
+ * (A*B)(i,j))). The default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param B
+ * @param C
+ * @param accum
+ */
+template <class SemiRing = ArithmeticSemiring, typename F, class Matrix>
+void MxM(const Matrix &A, const Matrix &B, Matrix &C, F accum) {
+    assert(A.numberOfColumns() == B.numberOfRows() && A.numberOfRows() == C.numberOfRows()
+           && B.numberOfColumns() == C.numberOfColumns());
+    assert(A.getZero() == SemiRing::zero() && B.getZero() == SemiRing::zero()
+           && C.getZero() == SemiRing::zero());
+
+    std::vector<NetworKit::Triplet> triplets;
+    NetworKit::SparseAccumulator spa(B.numberOfRows());
+    for (NetworKit::index i = 0; i < A.numberOfRows(); ++i) {
+        A.forNonZeroElementsInRow(i, [&](NetworKit::index k, double w1) {
+            B.forNonZeroElementsInRow(k, [&](NetworKit::index j, double w2) {
+                spa.scatter(SemiRing::mult(w1, w2), j, *SemiRing::add);
+            });
+        });
+
+        spa.gather([&](NetworKit::index i, NetworKit::index j, double value) {
+            triplets.push_back({i, j, value});
+        });
+
+        spa.increaseRow();
+    }
+
+    Matrix temp(A.numberOfRows(), B.numberOfRows(), triplets, A.getZero());
+    C = eWiseBinOp<SemiRing, Matrix>(C, temp, accum);
+}
+
+/**
+ * Computes the matrix-vector product of matrix @a A and Vector @a v. The default Semiring is the
+ * ArithmeticSemiring.
+ * @param A
+ * @param v
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+NetworKit::Vector MxV(const Matrix &A, const NetworKit::Vector &v) {
+    assert(!v.isTransposed());
+    assert(A.numberOfColumns() == v.getDimension());
+    assert(A.getZero() == SemiRing::zero());
+    NetworKit::Vector result(A.numberOfRows(), A.getZero());
+
+    A.parallelForNonZeroElementsInRowOrder(
+        [&](NetworKit::index i, NetworKit::index j, double value) {
+            result[i] = SemiRing::add(result[i], SemiRing::mult(value, v[j]));
+        });
+
+    return result;
+}
+
+/**
+ * Computes the matrix-vector product of matrix @a A and Vector @a v and adds it to @a c where the
+ * add operation is that of the specified Semiring (i.e. c[i] = SemiRing::add(c[i], (A*v)[i]). The
+ * default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param v
+ * @param c
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+void MxV(const Matrix &A, const NetworKit::Vector &v, NetworKit::Vector &c) {
+    assert(!v.isTransposed());
+    assert(A.numberOfColumns() == v.getDimension());
+    assert(A.getZero() == SemiRing::zero());
+
+    A.parallelForNonZeroElementsInRowOrder(
+        [&](NetworKit::index i, NetworKit::index j, double value) {
+            c[i] = SemiRing::add(c[i], SemiRing::mult(value, v[j]));
+        });
+}
+
+/**
+ * Computes the matrix-vector product of matrix @a A and Vector @a v and adds it to @a c where the
+ * add operation is that of the specified binary function @a accum (i.e. c[i] = accum(c[i],
+ * (A*v)[i]). The default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param v
+ * @param c
+ */
+template <class SemiRing = ArithmeticSemiring, typename F, class Matrix>
+void MxV(const Matrix &A, const NetworKit::Vector &v, NetworKit::Vector &c, F accum) {
+    assert(!v.isTransposed());
+    assert(A.numberOfColumns() == v.getDimension());
+    assert(A.getZero() == SemiRing::zero());
+
+    A.parallelForNonZeroElementsInRowOrder(
+        [&](NetworKit::index i, NetworKit::index j, double value) {
+            c[i] = accum(c[i], SemiRing::mult(value, v[j]));
+        });
+}
+
+/**
+ * Computes SemiRing::add(A(i,j), B(i,j)) for all i,j element-wise and returns the resulting matrix.
+ * The default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param B
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+Matrix eWiseAdd(const Matrix &A, const Matrix &B) {
+    return eWiseBinOp<SemiRing, Matrix>(
+        A, B, [](const double a, const double b) { return SemiRing::add(a, b); });
+}
+
+/**
+ * Computes SemiRing::mult(A(i,j), B(i,j)) for all i,j element-wise and returns the resulting
+ * matrix. The default Semiring is the ArithmeticSemiring.
+ * @param A
+ * @param B
+ * @return
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+Matrix eWiseMult(const Matrix &A, const Matrix &B) {
+    return eWiseBinOp<SemiRing, Matrix>(
+        A, B, [](const double a, const double b) { return SemiRing::mult(a, b); });
+}
+
+/**
+ * Computes the row-reduction of the @a matrix and returns the result as a vector. That is, the
+ * elements of each row are summed up to form the respective entry in the result vector. The add
+ * operator is that of the specified Semiring. The default Semiring is the ArithmeticSemiring.
+ * @param matrix
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+NetworKit::Vector rowReduce(const Matrix &matrix) {
+    assert(matrix.getZero() == SemiRing::zero());
+    NetworKit::Vector rowReduction(matrix.numberOfRows(), 0.0);
+
+#pragma omp parallel for
+    for (NetworKit::omp_index i = 0; i < static_cast<NetworKit::omp_index>(matrix.numberOfRows());
+         ++i) {
+        matrix.forNonZeroElementsInRow(i, [&](NetworKit::index, double value) {
+            rowReduction[i] = SemiRing::add(rowReduction[i], value);
+        });
+    }
+
+    return rowReduction;
+}
+
+/**
+ * Computes the column-reduction of the @a matrix and returns the result as a Vector. That is, the
+ * elements of each column are summed up to form the respective entry in the result Vector. The add
+ * operator is that of the specified Semiring. The default Semiring is the ArithmeticSemiring.
+ * @param matrix
+ */
+template <class SemiRing = ArithmeticSemiring, class Matrix>
+NetworKit::Vector columnReduce(const Matrix &matrix) {
+    assert(matrix.getZero() == SemiRing::zero());
+    NetworKit::Vector columnReduction(matrix.numberOfColumns(), 0.0);
+
+    matrix.forNonZeroElementsInRowOrder([&](NetworKit::index, NetworKit::index j, double value) {
+        columnReduction[j] = SemiRing::add(columnReduction[j], value);
+    });
+
+    return columnReduction;
+}
+
+} // namespace GraphBLAS
+
+#endif // NETWORKIT_ALGEBRAIC_GRAPH_BLAS_HPP_

package/vendor/include/networkit/algebraic/MatrixTools.hpp

@@ -0,0 +1,156 @@
+/*
+ * MatrixTools.hpp
+ *
+ *  Created on: May 31, 2016
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_ALGEBRAIC_MATRIX_TOOLS_HPP_
+#define NETWORKIT_ALGEBRAIC_MATRIX_TOOLS_HPP_
+
+#include <atomic>
+#include <cmath>
+
+#include <networkit/Globals.hpp>
+#include <networkit/algebraic/AlgebraicGlobals.hpp>
+#include <networkit/algebraic/CSRMatrix.hpp>
+#include <networkit/algebraic/DenseMatrix.hpp>
+#include <networkit/algebraic/DynamicMatrix.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace MatrixTools {
+
+/**
+ * Checks if @a matrix is symmetric.
+ * @param matrix
+ * @return True if @a matrix is symmetric, otherwise false.
+ */
+template <class Matrix>
+bool isSymmetric(const Matrix &matrix) {
+    bool output = true;
+    matrix.forNonZeroElementsInRowOrder(
+        [&](NetworKit::index i, NetworKit::index j, NetworKit::edgeweight w) {
+            if (std::fabs(matrix(j, i) - w) > NetworKit::FLOAT_EPSILON) {
+                output = false;
+                return;
+            }
+        });
+    return output;
+}
+
+/**
+ * Checks if @a matrix is symmetric diagonally dominant (SDD).
+ * @param matrix
+ * @return True if @a matrix is SDD, false otherwise.
+ */
+template <class Matrix>
+bool isSDD(const Matrix &matrix) {
+    if (!isSymmetric(matrix)) {
+        return false;
+    }
+
+    /* Criterion: a_ii >= \sum_{j != i} a_ij */
+    std::vector<double> row_sum(matrix.numberOfRows());
+    matrix.parallelForNonZeroElementsInRowOrder(
+        [&](NetworKit::node i, NetworKit::node j, double value) {
+            if (i == j) {
+                row_sum[i] += value;
+            } else {
+                row_sum[i] -= std::fabs(value);
+            }
+        });
+
+    return std::all_of(row_sum.begin(), row_sum.end(),
+                       [](double val) { return val > -NetworKit::FLOAT_EPSILON; });
+}
+
+/**
+ * Checks if @a matrix is a Laplacian matrix.
+ * @param matrix
+ * @return True if @a matrix is a Laplacian matrix, false otherwise.
+ */
+template <typename Matrix>
+bool isLaplacian(const Matrix &matrix) {
+    if (!isSymmetric(matrix)) {
+        return false;
+    }
+
+    /* Criterion: \forall_i \sum_j A_ij = 0  */
+    std::vector<double> row_sum(matrix.numberOfRows());
+    std::atomic<bool> right_sign(true);
+    matrix.parallelForNonZeroElementsInRowOrder(
+        [&](NetworKit::node i, NetworKit::node j, double value) {
+            if (i != j && value > NetworKit::FLOAT_EPSILON) {
+                right_sign = false;
+            }
+            row_sum[i] += value;
+        });
+
+    return right_sign && std::all_of(row_sum.begin(), row_sum.end(), [](double val) {
+               return std::fabs(val) < NetworKit::FLOAT_EPSILON;
+           });
+}
+
+/**
+ * Computes a graph having the given @a laplacian.
+ * @param laplacian
+ * @return The graph having a Laplacian equal to @a laplacian.
+ */
+template <class Matrix>
+NetworKit::GraphW laplacianToGraph(const Matrix &laplacian) {
+    assert(isLaplacian(laplacian));
+    NetworKit::GraphW G(std::max(laplacian.numberOfRows(), laplacian.numberOfColumns()), true,
+                        false);
+    laplacian.forNonZeroElementsInRowOrder(
+        [&](NetworKit::node u, NetworKit::node v, NetworKit::edgeweight weight) {
+            if (u != v) { // exclude diagonal
+                if (u < v) {
+                    G.addEdge(u, v, -weight);
+                }
+            }
+        });
+
+    return G;
+}
+
+/**
+ * Interprets the @a matrix as adjacency matrix of a graph. If @a matrix is non-symmetric, the graph
+ * will be directed.
+ * @param matrix
+ * @return The graph having an adjacency matrix equal to @a matrix.
+ */
+template <class Matrix>
+NetworKit::GraphW matrixToGraph(const Matrix &matrix) {
+    bool directed = !isSymmetric(matrix);
+    NetworKit::GraphW G(std::max(matrix.numberOfRows(), matrix.numberOfColumns()), true, directed);
+    matrix.forNonZeroElementsInRowOrder(
+        [&](NetworKit::node u, NetworKit::node v, NetworKit::edgeweight weight) {
+            if (directed || u <= v) {
+                G.addEdge(u, v, weight);
+            }
+        });
+
+    return G;
+}
+
+/**
+ * Converts the @a other matrix into a equivalent matrix of the template parametrized type.
+ * @param other The input Matrix.
+ * @return Matrix of type DenseMatrix, CSRMatrix or DynamicMatrix.
+ */
+template <class ToMatrix, class FromMatrix>
+ToMatrix matrixTo(const FromMatrix &other) {
+    int nRows = other.numberOfRows();
+    int nCols = other.numberOfColumns();
+    ToMatrix ResMat(nRows, nCols, other.getZero());
+
+    other.forNonZeroElementsInRowOrder(
+        [&ResMat](int i, int j, double val) { ResMat.setValue(i, j, val); });
+
+    return ResMat;
+}
+
+} // namespace MatrixTools
+
+#endif // NETWORKIT_ALGEBRAIC_MATRIX_TOOLS_HPP_

package/vendor/include/networkit/algebraic/Semirings.hpp

@@ -0,0 +1,171 @@
+/*
+ * Semirings.hpp
+ *
+ *  Created on: May 31, 2016
+ *      Author: Michael Wegner (michael.wegner@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_ALGEBRAIC_SEMIRINGS_HPP_
+#define NETWORKIT_ALGEBRAIC_SEMIRINGS_HPP_
+
+#include <algorithm>
+
+// *****************************************************
+// 					Semiring Definitions
+// *****************************************************
+
+/**
+ * @ingroup algebraic
+ * add: arithmetic add
+ * mult: arithmetic multiplication
+ * zero: 0
+ * one: 1
+ * codomain = (-infty, +infty)
+ */
+class ArithmeticSemiring final {
+public:
+    ArithmeticSemiring() = default;
+    ~ArithmeticSemiring() = default;
+
+    inline static double add(double a, double b) { return a + b; }
+
+    inline static double mult(double a, double b) { return a * b; }
+
+    inline static double zero() { return 0; };
+
+    inline static double one() { return 1; };
+};
+
+/**
+ * @ingroup algebraic
+ * add: min
+ * mult: arithmetic add
+ * zero: +infty
+ * one: 0
+ * codomain = (-infty, +infty]
+ */
+class MinPlusSemiring final {
+public:
+    MinPlusSemiring() = default;
+    ~MinPlusSemiring() = default;
+
+    inline static double add(double a, double b) { return std::min(a, b); }
+
+    inline static double mult(double a, double b) { return a + b; }
+
+    inline static double zero() { return std::numeric_limits<double>::infinity(); };
+
+    inline static double one() { return 0; };
+};
+
+/**
+ * @ingroup algebraic
+ * add: max
+ * mult: arithmetic add
+ * zero: -infty
+ * one: 0
+ * codomain = [-infty, +infty)
+ */
+class MaxPlusSemiring final {
+public:
+    MaxPlusSemiring() = default;
+    ~MaxPlusSemiring() = default;
+
+    inline static double add(double a, double b) { return std::max(a, b); }
+
+    inline static double mult(double a, double b) { return a + b; }
+
+    inline static double zero() { return -std::numeric_limits<double>::infinity(); };
+
+    inline static double one() { return 0; };
+};
+
+/**
+ * @ingroup algebraic
+ * add: min
+ * mult: max
+ * zero: +infty
+ * one: -infty
+ * codomain = [-infty, +infty]
+ */
+class MinMaxSemiring final {
+public:
+    MinMaxSemiring() = default;
+    ~MinMaxSemiring() = default;
+
+    inline static double add(double a, double b) { return std::min(a, b); }
+
+    inline static double mult(double a, double b) { return std::max(a, b); }
+
+    inline static double zero() { return std::numeric_limits<double>::infinity(); };
+
+    inline static double one() { return -std::numeric_limits<double>::infinity(); };
+};
+
+/**
+ * @ingroup algebraic
+ * add: max
+ * mult: min
+ * zero: -infty
+ * one: +infty
+ * codomain = [-infty, +infty]
+ */
+class MaxMinSemiring final {
+public:
+    MaxMinSemiring() = default;
+    ~MaxMinSemiring() = default;
+
+    inline static double add(double a, double b) { return std::max(a, b); }
+
+    inline static double mult(double a, double b) { return std::min(a, b); }
+
+    inline static double zero() { return -std::numeric_limits<double>::infinity(); };
+
+    inline static double one() { return 0; };
+};
+
+/**
+ * @ingroup algebraic
+ * add: logical or
+ * mult: logical and
+ * zero: 0
+ * one: 1
+ * codomain = [-infty, +infty]
+ */
+class IntLogicalSemiring final {
+public:
+    IntLogicalSemiring() = default;
+    ~IntLogicalSemiring() = default;
+
+    inline static double add(double a, double b) { return (int)a || (int)b; }
+
+    inline static double mult(double a, double b) { return (int)a && (int)b; }
+
+    inline static double zero() { return 0; };
+
+    inline static double one() { return 1; };
+};
+
+/**
+ * @ingroup algebraic
+ * add: xor
+ * mult: bitwise and
+ * zero: 0
+ * one: 1
+ * codomain = [0, 1]
+ */
+class GaloisFieldSemiring final {
+public:
+    GaloisFieldSemiring() = default;
+    ~GaloisFieldSemiring() = default;
+
+    inline static double add(double a, double b) { return (int)a ^ (int)b; }
+
+    inline static double mult(double a, double b) { return (int)a & (int)b; }
+
+    inline static double zero() { return 0; };
+
+    inline static double one() { return 1; };
+};
+
+#endif // NETWORKIT_ALGEBRAIC_SEMIRINGS_HPP_