@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/networkit/algebraic/algorithms/AlgebraicMatchingCoarsening.hpp

@@ -1,96 +0,0 @@
-/*
- * AlgebraicMatchingCoarsening.hpp
- *
- *  Created on: Jul 12, 2016
- *      Author: Michael Wegner (michael.wegner@student.kit.edu)
- */
-
-#ifndef NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_MATCHING_COARSENING_HPP_
-#define NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_MATCHING_COARSENING_HPP_
-
-#include <networkit/algebraic/AlgebraicGlobals.hpp>
-#include <networkit/coarsening/GraphCoarsening.hpp>
-#include <networkit/matching/Matching.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup algebraic
- * Implements an algebraic version of the MatchingCoarsening algorithm by computing a projection
- * matrix from fine to coarse.
- */
-template <class Matrix>
-class AlgebraicMatchingCoarsening final : public GraphCoarsening {
-public:
-    /**
-     * Constructs an instance of AlgebraicMatchingCoarsening for the given Graph @a graph and the
-     * corresponding Matching @a matching. If @a noSelfLoops is set to true (false by default), no
-     * self-loops are created during the coarsening.
-     * @param graph
-     * @param matching
-     * @param noSelfLoops
-     */
-    AlgebraicMatchingCoarsening(const Graph &graph, const Matching &matching,
-                                bool noSelfLoops = false);
-
-    /**
-     * Computes the coarsening for the graph using the given matching.
-     */
-    void run() override;
-
-private:
-    Matrix A; // adjacency matrix of the graph
-    Matrix P; // projection matrix
-    bool noSelfLoops;
-};
-
-template <class Matrix>
-AlgebraicMatchingCoarsening<Matrix>::AlgebraicMatchingCoarsening(const Graph &graph,
-                                                                 const Matching &matching,
-                                                                 bool noSelfLoops)
-    : GraphCoarsening(graph), A(Matrix::adjacencyMatrix(graph)), noSelfLoops(noSelfLoops) {
-    if (G->isDirected())
-        throw std::runtime_error("Only defined for undirected graphs.");
-    nodeMapping.resize(graph.numberOfNodes());
-    std::vector<Triplet> triplets(graph.numberOfNodes());
-
-    count numCoarse = graph.numberOfNodes() - matching.size(graph);
-    index idx = 0;
-    graph.forNodes([&](node u) {
-        index mate = matching.mate(u);
-        if ((mate == none) || (u < mate)) {
-            // vertex u is carried over to the new level
-            nodeMapping[u] = idx;
-            ++idx;
-        } else {
-            // vertex u is not carried over, receives ID of mate
-            nodeMapping[u] = nodeMapping[mate];
-        }
-
-        triplets[u] = {u, nodeMapping[u], 1};
-    });
-
-    P = Matrix(graph.numberOfNodes(), numCoarse, triplets); // dimensions: fine x coarse
-}
-
-template <class Matrix>
-void AlgebraicMatchingCoarsening<Matrix>::run() {
-    Matrix coarseAdj =
-        P.transpose() * A
-        * P; // Matrix::mTmMultiply performs worse due to high sparsity of P (nnz = n)
-
-    Gcoarsened = GraphW(coarseAdj.numberOfRows(), true);
-    coarseAdj.forNonZeroElementsInRowOrder([&](node u, node v, edgeweight weight) {
-        if (u == v && !noSelfLoops) {
-            Gcoarsened.addEdge(u, v, weight / 2.0);
-        } else if (u < v) {
-            Gcoarsened.addEdge(u, v, weight);
-        }
-    });
-
-    hasRun = true;
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_MATCHING_COARSENING_HPP_

package/vendor/include/networkit/algebraic/algorithms/AlgebraicPageRank.hpp

@@ -1,145 +0,0 @@
-/*
- * AlgebraicPageRank.hpp
- *
- *  Created on: Jun 20, 2016
- *      Author: Michael Wegner (michael.wegner@student.kit.edu)
- */
-
-#ifndef NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_PAGE_RANK_HPP_
-#define NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_PAGE_RANK_HPP_
-
-#include <networkit/auxiliary/Parallel.hpp>
-#include <networkit/centrality/Centrality.hpp>
-
-#include <networkit/algebraic/GraphBLAS.hpp>
-#include <networkit/algebraic/Vector.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup algebraic
- * Implementation of PageRank using the GraphBLAS interface.
- */
-template <class Matrix>
-class AlgebraicPageRank final : public Centrality {
-public:
-    /**
-     * Constructs an instance of AlgebraicPageRank for the given @a graph. Page rank uses the
-     * damping factor @a damp and the tolerance @a tol.
-     * @param graph
-     * @param damp
-     * @param tol
-     */
-    AlgebraicPageRank(const Graph &graph, const double damp = 0.85, const double tol = 1e-8)
-        : Centrality(graph), damp(damp), tol(tol) {
-        Matrix A = Matrix::adjacencyMatrix(graph);
-        // normalize At by out-degree
-        Vector invOutDeg = GraphBLAS::rowReduce(A);
-#pragma omp parallel for
-        for (omp_index i = 0; i < static_cast<omp_index>(invOutDeg.getDimension()); ++i) {
-            invOutDeg[i] = 1.0 / invOutDeg[i];
-        }
-
-        std::vector<Triplet> mTriplets(A.nnz());
-        index idx = 0;
-        A.forNonZeroElementsInRowOrder([&](index i, index j, double value) {
-            mTriplets[idx++] = {j, i, damp * value * invOutDeg[i]};
-        });
-        M = std::move(Matrix(A.numberOfRows(), mTriplets));
-    }
-
-    void run() override;
-
-    /**
-     * Get a vector containing the betweenness score for each node in the graph.
-     *
-     * @return The betweenness scores calculated by @ref run().
-     */
-    const std::vector<double> &scores() const override;
-
-    /**
-     * Get a vector of pairs sorted into descending order. Each pair contains a node and the
-     * corresponding score calculated by @ref run().
-     * @return A vector of pairs.
-     */
-    std::vector<std::pair<node, double>> ranking() override;
-
-    /**
-     * Get the betweenness score of node @a v calculated by @ref run().
-     *
-     * @param v A node.
-     * @return The betweenness score of node @a v.
-     */
-    double score(node v) override;
-
-    /**
-     * Get the theoretical maximum of centrality score in the given graph.
-     *
-     * @return The maximum centrality score.
-     */
-    double maximum() override { return 1.0; }
-
-private:
-    Matrix M;
-
-    const double damp;
-    const double tol;
-};
-
-template <class Matrix>
-void AlgebraicPageRank<Matrix>::run() {
-    count n = M.numberOfRows();
-    double teleportProb = (1.0 - damp) / (double)n;
-    Vector rank(n, 1.0 / (double)n);
-    Vector lastRank;
-
-    do {
-        lastRank = rank;
-        rank = M * rank;
-        rank.apply([&](double value) { return value += teleportProb; });
-    } while ((rank - lastRank).length() > tol);
-
-    double sum = 0.0;
-#pragma omp parallel for reduction(+ : sum)
-    for (omp_index i = 0; i < static_cast<omp_index>(rank.getDimension()); ++i) {
-        sum += rank[i];
-    }
-
-    scoreData.resize(n, 0);
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(rank.getDimension()); ++i) {
-        scoreData[i] = rank[i] / sum;
-    }
-
-    hasRun = true;
-}
-
-template <class Matrix>
-const std::vector<double> &AlgebraicPageRank<Matrix>::scores() const {
-    assureFinished();
-    return scoreData;
-}
-
-template <class Matrix>
-std::vector<std::pair<node, double>> AlgebraicPageRank<Matrix>::ranking() {
-    assureFinished();
-    std::vector<std::pair<node, double>> ranking;
-    for (index i = 0; i < scoreData.size(); ++i) {
-        ranking.push_back({i, scoreData[i]});
-    }
-    Aux::Parallel::sort(
-        ranking.begin(), ranking.end(),
-        [](std::pair<node, double> x, std::pair<node, double> y) { return x.second > y.second; });
-    return ranking;
-}
-
-template <class Matrix>
-double AlgebraicPageRank<Matrix>::score(node v) {
-    assureFinished();
-    return scoreData.at(v);
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_PAGE_RANK_HPP_

package/vendor/include/networkit/algebraic/algorithms/AlgebraicSpanningEdgeCentrality.hpp

@@ -1,122 +0,0 @@
-/*
- * AlgebraicSpanningEdgeCentrality.hpp
- *
- *  Created on: Jul 12, 2016
- *      Author: Michael Wegner (michael.wegner@student.kit.edu)
- */
-
-#ifndef NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_SPANNING_EDGE_CENTRALITY_HPP_
-#define NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_SPANNING_EDGE_CENTRALITY_HPP_
-
-#include <atomic>
-#include <cmath>
-
-#include <networkit/centrality/Centrality.hpp>
-#include <networkit/numerics/LAMG/Lamg.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup algebraic
- * Implementation of Spanning edge centrality with algebraic notation.
- */
-template <class Matrix>
-class AlgebraicSpanningEdgeCentrality : public Centrality {
-public:
-    /**
-     * Constructs an instance of the AlgebraicSpanningEdgeCentrality algorithm for the given Graph
-     * @a graph. The tolerance @a tol is used to control the approximation error when approximating
-     * the spanning edge centrality for @a graph.
-     * @param graph
-     * @param tol
-     */
-    AlgebraicSpanningEdgeCentrality(const Graph &graph, double tol = 0.1)
-        : Centrality(graph), tol(tol) {}
-
-    /**
-     * Compute spanning edge centrality exactly.
-     */
-    void run() override;
-
-    /**
-     * Approximate spanning edge centrality scores with the Johnson-Lindenstrauss transform.
-     */
-    void runApproximation();
-
-private:
-    double tol;
-};
-
-template <class Matrix>
-void AlgebraicSpanningEdgeCentrality<Matrix>::run() {
-    const count n = G.numberOfNodes();
-    const count m = G.numberOfEdges();
-    scoreData.clear();
-    scoreData.resize(m, 0.0);
-
-    std::vector<Vector> rhs(m, Vector(n));
-    this->G.parallelForEdges([&](node u, node v, edgeid e) {
-        rhs[e][u] = +1;
-        rhs[e][v] = -1;
-    });
-
-    std::vector<Vector> solutions(m, Vector(n));
-
-    Lamg<Matrix> lamg(1e-5);
-    lamg.setupConnected(Matrix::laplacianMatrix(this->G));
-    lamg.parallelSolve(rhs, solutions);
-
-    this->G.parallelForEdges([&](node u, node v, edgeid e) {
-        double diff = solutions[e][u] - solutions[e][v];
-        scoreData[e] = std::fabs(diff);
-    });
-
-    hasRun = true;
-}
-
-template <class Matrix>
-void AlgebraicSpanningEdgeCentrality<Matrix>::runApproximation() {
-    const count n = G.numberOfNodes();
-    const count m = G.numberOfEdges();
-    scoreData.clear();
-    scoreData.resize(m, 0.0);
-    double epsilon2 = tol * tol;
-    const count k = std::ceil(std::log2(n)) / epsilon2;
-    double randTab[2] = {1.0 / std::sqrt(k), -1.0 / std::sqrt(k)};
-
-    const auto rhsLoader = [&](count, Vector &yRow) -> Vector & {
-        yRow.fill(0);
-        G.forEdges([&](node u, node v, edgeweight w, index) {
-            double rand = randTab[Aux::Random::integer(1)];
-            yRow[u] += w * rand;
-            yRow[v] -= w * rand;
-        });
-        return yRow;
-    };
-
-    std::vector<std::atomic<double>> scoreDataAtom(m);
-    const auto resultProcessor = [&](count, const Vector &zRow) {
-        G.forEdges([&](node u, node v, edgeid e) {
-            double diff = (zRow[u] - zRow[v]);
-            diff *= diff;
-            for (double old = scoreDataAtom[e].load(); !scoreDataAtom[e].compare_exchange_strong(
-                     old, old + diff, std::memory_order_relaxed);)
-                ;
-        });
-    };
-
-    Lamg<Matrix> lamg(1e-5);
-    lamg.setupConnected(Matrix::laplacianMatrix(this->G));
-    lamg.parallelSolve(rhsLoader, resultProcessor, std::make_pair(k, n));
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(m); ++i) {
-        scoreData[i] = scoreDataAtom[i].load(std::memory_order_relaxed);
-    }
-
-    hasRun = true;
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_SPANNING_EDGE_CENTRALITY_HPP_

package/vendor/include/networkit/algebraic/algorithms/AlgebraicTriangleCounting.hpp

@@ -1,76 +0,0 @@
-/*
- * AlgebraicTriangleCounting.hpp
- *
- *  Created on: Jul 12, 2016
- *      Author: Michael Wegner (michael.wegner@student.kit.edu)
- */
-
-#ifndef NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_TRIANGLE_COUNTING_HPP_
-#define NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_TRIANGLE_COUNTING_HPP_
-
-#include <networkit/base/Algorithm.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup algebraic
- * Implements a triangle counting algorithm for nodes based on algebraic methods.
- */
-template <class Matrix>
-class AlgebraicTriangleCounting : public Algorithm {
-public:
-    /**
-     * Creates an instance of AlgebraicTriangleCounting for the given Graph @a graph.
-     * @param graph
-     */
-    AlgebraicTriangleCounting(const Graph &graph)
-        : A(Matrix::adjacencyMatrix(graph)), directed(graph.isDirected()) {}
-
-    /**
-     * Computes the number of triangles each node is part of. A triangle is considered as a set of
-     * nodes (i.e. if there is a triangle (u,v,w) it only counts as one triangle at each node).
-     */
-    void run() override;
-
-    /**
-     * Returns the score of node @a u.
-     * @param u
-     */
-    count score(node u) const {
-        assureFinished();
-        assert(u < A.numberOfRows());
-        return nodeScores[u];
-    }
-
-    /**
-     * Returns the scores for all nodes of the graph.
-     */
-    const std::vector<count> &getScores() const {
-        assureFinished();
-        return nodeScores;
-    }
-
-private:
-    Matrix A;
-    bool directed;
-    std::vector<count> nodeScores;
-};
-
-template <class Matrix>
-void AlgebraicTriangleCounting<Matrix>::run() {
-    Matrix powA = A * A * A;
-
-    nodeScores.clear();
-    nodeScores.resize(A.numberOfRows(), 0);
-
-#pragma omp parallel for
-    for (omp_index i = 0; i < static_cast<omp_index>(powA.numberOfRows()); ++i) {
-        nodeScores[i] = directed ? powA(i, i) : powA(i, i) / 2.0;
-    }
-
-    hasRun = true;
-}
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_ALGEBRAIC_ALGORITHMS_ALGEBRAIC_TRIANGLE_COUNTING_HPP_

package/vendor/include/networkit/auxiliary/AlignedAllocator.hpp

@@ -1,113 +0,0 @@
-
-#ifndef NETWORKIT_AUXILIARY_ALIGNED_ALLOCATOR_HPP_
-#define NETWORKIT_AUXILIARY_ALIGNED_ALLOCATOR_HPP_
-
-#include <stdexcept>
-
-/**
- * Allocator for aligned data.
- *
- * Modified from the Mallocator from Stephan T. Lavavej.
- * <http://blogs.msdn.com/b/vcblog/archive/2008/08/28/the-mallocator.aspx>
- */
-template <typename T, size_t Alignment>
-class AlignedAllocator {
-public:
-    // The following will be the same for virtually all allocators.
-    typedef T *pointer;
-    typedef const T *const_pointer;
-    typedef T &reference;
-    typedef const T &const_reference;
-    typedef T value_type;
-    typedef size_t size_type;
-    typedef ptrdiff_t difference_type;
-
-    T *address(T &r) const { return &r; }
-
-    const T *address(const T &s) const { return &s; }
-
-    size_t max_size() const {
-        // The following has been carefully written to be independent of
-        // the definition of size_t and to avoid signed/unsigned warnings.
-        return (static_cast<size_t>(0) - static_cast<size_t>(1)) / sizeof(T);
-    }
-
-    // The following must be the same for all allocators.
-    template <typename U>
-    struct rebind {
-        typedef AlignedAllocator<U, Alignment> other;
-    };
-
-    bool operator!=(const AlignedAllocator &other) const { return !(*this == other); }
-
-    void construct(T *const p, const T &t) const {
-        void *const pv = static_cast<void *>(p);
-
-        new (pv) T(t);
-    }
-
-    void destroy(T *const p) const { p->~T(); }
-
-    // Returns true if and only if storage allocated from *this
-    // can be deallocated from other, and vice versa.
-    // Always returns true for stateless allocators.
-    bool operator==(const AlignedAllocator &) const { return true; }
-
-    // Default constructor, copy constructor, rebinding constructor, and destructor.
-    // Empty for stateless allocators.
-    AlignedAllocator() {}
-
-    AlignedAllocator(const AlignedAllocator &) {}
-
-    template <typename U>
-    AlignedAllocator(const AlignedAllocator<U, Alignment> &) {}
-
-    ~AlignedAllocator() {}
-
-    // The following will be different for each allocator.
-    T *allocate(size_t n) const {
-        // The return value of allocate(0) is unspecified.
-        // Mallocator returns NULL in order to avoid depending
-        // on malloc(0)'s implementation-defined behavior
-        // (the implementation can define malloc(0) to return NULL,
-        // in which case the bad_alloc check below would fire).
-        // All allocators can return NULL in this case.
-        if (n == 0)
-            return NULL;
-
-        // All allocators should contain an integer overflow check.
-        // The Standardization Committee recommends that std::length_error
-        // be thrown in the case of integer overflow.
-        if (n > max_size())
-            throw std::length_error("AlignedAllocator<T>::allocate() - Integer overflow.");
-
-        // Mallocator wraps malloc().
-        void *const pv = _mm_malloc(n * sizeof(T), Alignment);
-
-        // Allocators should throw std::bad_alloc in the case of memory allocation failure.
-        if (pv == NULL)
-            throw std::bad_alloc();
-
-        return static_cast<T *>(pv);
-    }
-
-    void deallocate(T *const p, size_t) const { _mm_free(p); }
-
-    // The following will be the same for all allocators that ignore hints.
-    template <typename U>
-    T *allocate(size_t n, const U * /* const hint */) const {
-        return allocate(n);
-    }
-
-    // Allocators are not required to be assignable, so
-    // all allocators should have a private unimplemented
-    // assignment operator. Note that this will trigger the
-    // off-by-default (enabled under /Wall) warning C4626
-    // "assignment operator could not be generated because a
-    // base class assignment operator is inaccessible" within
-    // the STL headers, but that warning is useless.
-private:
-    AlignedAllocator &operator=(const AlignedAllocator &);
-};
-
-#endif // NETWORKIT_AUXILIARY_ALIGNED_ALLOCATOR_HPP_

package/vendor/include/networkit/auxiliary/ArrayTools.hpp

@@ -1,85 +0,0 @@
-#ifndef NETWORKIT_AUXILIARY_ARRAY_TOOLS_HPP_
-#define NETWORKIT_AUXILIARY_ARRAY_TOOLS_HPP_
-
-#include <cmath>
-#include <utility>
-#include <vector>
-
-#include <networkit/Globals.hpp>
-
-#include <tlx/math/integer_log2.hpp>
-
-namespace Aux {
-namespace ArrayTools {
-
-template <class ArrayIt, class PermIt>
-void applyPermutation(ArrayIt first, ArrayIt last, PermIt permFirst) {
-
-    using PermType = typename std::iterator_traits<PermIt>::value_type;
-    static_assert(std::is_integral<PermType>::value, "Elements of permutation must be integral.");
-
-    const size_t arraySize =
-        static_cast<typename std::iterator_traits<ArrayIt>::difference_type>(last - first);
-
-    const size_t usedBitsInPerm = tlx::integer_log2_ceil(arraySize);
-    // Avoid to use the sign bit if signed integral
-    const size_t bitsInPerm = sizeof(PermType) * 8 - (std::is_signed<PermType>::value ? 1 : 0);
-
-    if (bitsInPerm == usedBitsInPerm) {
-        // All bits in permutation are needed, we mark swapped elements with a bool vector
-        std::vector<bool> swapped(arraySize);
-        for (size_t i = 0; i < arraySize; ++i) {
-            if (swapped[i])
-                continue;
-
-            size_t cur = i;
-            swapped[cur] = true;
-            auto tmp = std::move(first[cur]);
-
-            while (static_cast<size_t>(permFirst[cur]) != i) {
-                first[cur] = std::move(first[permFirst[cur]]);
-                cur = permFirst[cur];
-                swapped[cur] = true;
-            }
-
-            first[cur] = std::move(tmp);
-        }
-    } else {
-        // Not all bits in the permutation are needed, we use the last (or, if signed integral,
-        // second to last) bit in the permutation to mark swapped elements
-        const auto mask = PermType{1} << (bitsInPerm - (std::is_signed<PermType>::value ? 2 : 1));
-
-        const auto swapped = [&permFirst, mask = mask](size_t i) -> bool {
-            return (permFirst[i] & mask) != 0;
-        };
-
-        const auto markSwapped = [&permFirst, mask = mask](size_t i) -> void {
-            permFirst[i] |= mask;
-        };
-
-        for (size_t i = 0; i < arraySize; ++i) {
-            if (swapped(i))
-                continue;
-
-            size_t cur = i;
-            markSwapped(cur);
-            auto tmp = std::move(first[cur]);
-
-            while (static_cast<size_t>(permFirst[cur] & ~mask) != i) {
-                first[cur] = std::move(first[permFirst[cur] & ~mask]);
-                cur = permFirst[cur] & ~mask;
-                markSwapped(cur);
-            }
-
-            first[cur] = std::move(tmp);
-        }
-
-        for (size_t i = 0; i < arraySize; ++i)
-            permFirst[i] &= ~mask;
-    }
-}
-
-} // namespace ArrayTools
-} // namespace Aux
-
-#endif // NETWORKIT_AUXILIARY_ARRAY_TOOLS_HPP_