@ladybugmem/icebug 0.1.0 → 0.1.2

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

@@ -1,323 +0,0 @@
-/*
- * 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

@@ -1,156 +0,0 @@
-/*
- * 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

@@ -1,171 +0,0 @@
-/*
- * 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_