@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/centrality/GroupClosenessLocalSwaps.hpp

@@ -0,0 +1,106 @@
+/*
+ *  GroupClosenessLocalSwaps.hpp
+ *
+ *  Created on: 19.12.2019
+ *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_CENTRALITY_GROUP_CLOSENESS_LOCAL_SWAPS_HPP_
+#define NETWORKIT_CENTRALITY_GROUP_CLOSENESS_LOCAL_SWAPS_HPP_
+
+#ifdef __AVX2__
+#include <immintrin.h>
+#include <networkit/auxiliary/AlignedAllocator.hpp>
+#endif // __AVX2__
+
+#include <limits>
+#include <stdexcept>
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+class GroupClosenessLocalSwaps final : public Algorithm {
+
+    static constexpr float maxInt16 = static_cast<float>(std::numeric_limits<uint16_t>::max());
+    // Number of random numbers generated at once
+    static constexpr count K = 16;
+
+public:
+    GroupClosenessLocalSwaps(const Graph &G, const std::vector<node> &group, count maxSwaps = 100);
+
+    /**
+     * Finds a group of nodes with high group closeness centrality. This is the LS-restrict
+     * algorithm presented in Angriman et al. "Local Search for Group Closeness Maximization on Big
+     * Graphs" IEEE BigData 2019. The algorithm takes as input a graph and an arbitrary group of
+     * nodes, and improves the group closeness of the given group by performing vertex exchanges.
+     *
+     * @param G A connected, undirected, and unweighted graph.
+     * @param first, last A range that contains the initial group of nodes.
+     * @param maxSwaps Maximum number of vertex exchanges allowed.
+     */
+    template <class InputIt>
+    GroupClosenessLocalSwaps(const Graph &graph, InputIt first, InputIt last, count maxSwaps = 100)
+        : G(&graph), group(first, last), maxSwaps(maxSwaps) {
+
+        if (G->isDirected())
+            throw std::runtime_error("Error, this algorithm does not support directed graphs.");
+
+        if (group.empty())
+            throw std::runtime_error("Error, empty group.");
+
+        if (G->isWeighted())
+            WARN("This algorithm does not support edge Weights, they will be ignored.");
+    }
+
+    /**
+     * Runs the algorithm.
+     */
+    void run() override;
+
+    /**
+     * Returns the computed group.
+     */
+    std::vector<node> groupMaxCloseness() const;
+
+    /**
+     * Returns the total number of vertex exchanges performed by the algorithm.
+     */
+    count numberOfSwaps() const;
+
+private:
+    const Graph *G;
+    std::vector<node> group, stack;
+    std::vector<uint32_t> distance, sumOfMins;
+    std::vector<bool> gamma, visited;
+    std::unordered_map<node, index> idxMap;
+    std::vector<int64_t> farness, farnessDecrease;
+
+    count maxSwaps, totalSwaps, stackSize;
+
+    void init();
+    void bfsFromGroup();
+    bool findAndSwap();
+    node estimateHighestDecrease();
+    void initRandomVector();
+    int64_t computeFarnessDecrease(node u);
+    void resetGamma(node x, index idx);
+
+#ifdef __AVX2__
+    union RandItem {
+        uint16_t items[K];
+        __m256i vec;
+    };
+    std::vector<RandItem, AlignedAllocator<RandItem, sizeof(RandItem)>> randVec;
+#else
+    std::vector<uint16_t> randVec;
+#endif // __AVX2__
+
+    std::vector<std::uniform_int_distribution<uint32_t>> intDistributions;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_GROUP_CLOSENESS_LOCAL_SWAPS_HPP_

package/vendor/include/networkit/centrality/GroupDegree.hpp

@@ -0,0 +1,155 @@
+/*
+ * GroupDegree.hpp
+ *
+ *  Created on: 20.04.2018
+ *      Author: Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_CENTRALITY_GROUP_DEGREE_HPP_
+#define NETWORKIT_CENTRALITY_GROUP_DEGREE_HPP_
+
+#include <omp.h>
+#include <ranges>
+
+#include <networkit/auxiliary/BucketPQ.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class GroupDegree : public Algorithm {
+
+public:
+    /**
+     * Finds the group with the highest group degree centrality according to the
+     * definition proposed in 'The centrality of groups and classes' by Everett et
+     * al. (The Journal of mathematical sociology, 1999). This is a submodular but
+     * non monotone function so the algorithm can find a solution that is at least
+     * 1/2 of the optimum. Worst-case running time is quadratic, but usually
+     * faster in real-world networks.
+     * The 'countGroupNodes' option also count the nodes inside the group in the
+     * score, this make the group degree monotone and submodular and the algorithm
+     * is guaranteed to return a (1 - 1/e)-approximation of the optimal solution.
+     *
+     * @param G A graph.
+     * @param k Size of the group of nodes
+     * @param countGroupNodes if nodes inside the group should be counted in the
+     * centrality score.
+     */
+    GroupDegree(const Graph &G, count k = 1, bool countGroupNodes = true);
+
+    /**
+     * Computes the group with maximum degree centrality of the graph passed in
+     * the constructor.
+     */
+    void run() override;
+
+    /**
+     * Returns the group with maximum degree centrality.
+     */
+    std::vector<node> groupMaxDegree();
+
+    /**
+     * Returns the score of the group with maximum degree centrality (i.e. the
+     * number of nodes outside the group that can be reached in one hop from at
+     * least one node in the group).
+     */
+    count getScore();
+
+    /**
+     * Returns the score of the given group.
+     */
+    count scoreOfGroup(const std::vector<node> &group) const;
+
+protected:
+    const Graph &G;
+    const count k;
+    const bool countGroupNodes;
+    count n;
+    std::vector<node> group;
+    std::vector<int64_t> gain;
+    std::vector<bool> reachable;
+    std::vector<bool> affected;
+    std::vector<bool> inGroup;
+    Aux::BucketPQ queue;
+    count groupScore;
+
+    void init();
+    void updateQueue();
+    void updateGroup();
+    void computeScore();
+    void checkGroup(const std::vector<node> &group) const;
+};
+
+inline std::vector<node> GroupDegree::groupMaxDegree() {
+    assureFinished();
+    return group;
+}
+
+inline count GroupDegree::getScore() {
+    assureFinished();
+    return groupScore;
+}
+
+inline void GroupDegree::computeScore() {
+    groupScore = std::ranges::count(reachable, true);
+
+    if (!countGroupNodes) {
+        groupScore -= k;
+    }
+}
+
+inline void GroupDegree::checkGroup(const std::vector<node> &group) const {
+    const count z = G.upperNodeIdBound();
+    std::vector<bool> check(z, false);
+#pragma omp parallel for
+    for (omp_index i = 0; i < static_cast<omp_index>(group.size()); ++i) {
+        node u = group[i];
+        if (u >= z) {
+            std::stringstream ss;
+            ss << "Error: node " << u << " is not in the graph.\n";
+            throw std::runtime_error(ss.str());
+        }
+        if (check[u]) {
+            std::stringstream ss;
+            ss << "Error: the group contains duplicates of node " << u << ".\n";
+            throw std::runtime_error(ss.str());
+        }
+        check[u] = true;
+    }
+}
+
+inline count GroupDegree::scoreOfGroup(const std::vector<node> &group) const {
+    checkGroup(group);
+    std::vector<bool> touched(n, false);
+    std::vector<bool> inGroup(n, false);
+
+    for (count i = 0; i < group.size(); ++i) {
+        inGroup[group[i]] = true;
+    }
+
+    auto processNeighbor = [&](const node u, const node v) {
+        if (inGroup[u]) {
+            touched[v] = true;
+        }
+    };
+
+    G.forNodes([&](node v) {
+        if (!inGroup[v]) {
+            G.forInNeighborsOf(v, [&](node u) { processNeighbor(u, v); });
+        }
+    });
+    count result = std::ranges::count(touched, true);
+    if (countGroupNodes) {
+        result += group.size();
+    }
+
+    return result;
+}
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_GROUP_DEGREE_HPP_

package/vendor/include/networkit/centrality/GroupHarmonicCloseness.hpp

@@ -0,0 +1,83 @@
+/*
+ * GroupHarmonicCloseness.hpp
+ *
+ * Created on: 15.12.2020
+ *     Author: Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_CENTRALITY_GROUP_HARMONIC_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_GROUP_HARMONIC_CLOSENESS_HPP_
+
+#include <memory>
+#include <vector>
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class GroupHarmonicCloseness final : public Algorithm {
+
+public:
+    /**
+     * Approximation algorithm for the group-harmonic maximization problem. The computed solutions
+     * have a guaranteed $\\lambda(1 - \\frac{1}{2e})$ (directed graphs) and
+     * $\\lambda(1 - \\frac{1}/{e})/2$ (undirected graphs) approximation ratio,
+     * where $\\lambda$ is the ratio
+     * between the minimal and the maximal edge weight. The algorithm is the one proposed in
+     * Angriman et al., ALENEX 2021. The worst-case running time of this approach is quadratic, but
+     * usually much faster in practice.
+     *
+     * @param G The input graph.
+     * @param k Size of the group of nodes.
+     */
+    GroupHarmonicCloseness(const Graph &G, count k = 1);
+
+    /**
+     * Runs the algorithm.
+     */
+    void run() override;
+
+    /**
+     * Returns the computed group.
+     *
+     * @return The computed group.
+     */
+    const std::vector<node> &groupMaxHarmonicCloseness() const;
+
+    /**
+     * Computes the group-harmonic score of the group of nodes in the given range.
+     *
+     * @param graph The input Graph.
+     * @param first,last The range that contains the vertices in the group.
+     *
+     * @returns The score of the group of nodes in the given range.
+     */
+    template <class InputIt>
+    static double scoreOfGroup(const Graph &graph, InputIt first, InputIt last);
+
+    class GroupHarmonicClosenessInterface : public Algorithm {
+    public:
+        std::vector<node> group;
+    };
+
+private:
+    const bool weighted;
+    // Always one between GroupHarmonicClosenessUnweighted and GroupHarmonicClosenessWeighted, see
+    // implementation.
+    std::unique_ptr<GroupHarmonicClosenessInterface> impl;
+
+    static double scoreOfGroup(const Graph &graph, const std::vector<node> &inputGroup);
+};
+
+template <class InputIt>
+double GroupHarmonicCloseness::scoreOfGroup(const Graph &graph, InputIt first, InputIt last) {
+    return scoreOfGroup(graph, {first, last});
+}
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_GROUP_HARMONIC_CLOSENESS_HPP_

package/vendor/include/networkit/centrality/HarmonicCloseness.hpp

@@ -0,0 +1,48 @@
+/*
+ * HarmonicCloseness.hpp
+ *
+ * Created on: 24.02.2018
+ * 		 Author: Eugenio Angriman
+ */
+
+#ifndef NETWORKIT_CENTRALITY_HARMONIC_CLOSENESS_HPP_
+#define NETWORKIT_CENTRALITY_HARMONIC_CLOSENESS_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class HarmonicCloseness : public Centrality {
+public:
+    /**
+     * Constructs the HarmonicCloseness class for the given Graph @a G. If
+     * the closeness scores should be normalized, then set @a normalized to
+     * <code>true</code>. The run() method takes O(nm) time, where n is the number
+     * of nodes and m is the number of edges of the graph.
+     *
+     * @param G The graph.
+     * @param normalized Set this parameter to <code>false</code> if scores should
+     * not be normalized into an interval of [0, 1]. Normalization only for
+     * unweighted graphs.
+     *
+     */
+    HarmonicCloseness(const Graph &G, bool normalized = true);
+
+    /**
+     * Computes the harmonic closeness centrality on the graph passed in
+     * constructor.
+     */
+    void run() override;
+
+    /*
+     * Returns the maximum possible harmonic closeness centrality that a node can
+     * have in a star graph with the same amount of nodes.
+     */
+    double maximum() override;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_HARMONIC_CLOSENESS_HPP_

package/vendor/include/networkit/centrality/KPathCentrality.hpp

@@ -0,0 +1,52 @@
+/*
+ * KPathCentrality.hpp
+ *
+ *  Created on: 05.10.2014
+ *      Author: nemes
+ */
+
+#ifndef NETWORKIT_CENTRALITY_K_PATH_CENTRALITY_HPP_
+#define NETWORKIT_CENTRALITY_K_PATH_CENTRALITY_HPP_
+
+#include <networkit/centrality/Centrality.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup centrality
+ */
+class KPathCentrality : public Centrality {
+public:
+    /*
+     * the maximum length of paths
+     * default value ln(n+m)
+     */
+    count k;
+    /*
+     * value in interval [-0.5, 0.5]
+     * tradeoff between runtime and precision
+     * -0.5: maximum precision, maximum runtime
+     *  0.5: lowest precision, lowest runtime
+     * default value 0.2
+     */
+    double alpha;
+
+    /**
+     * Constructs the K-Path Centrality class for the given Graph @a G.
+     *
+     * @param G The graph.
+     * @param alpha tradeoff between precision and runtime.
+     * @param k maximum length of paths.
+     * TODO running times
+     */
+    KPathCentrality(const Graph &G, double alpha = 0.2, count k = 0);
+
+    /**
+     * Computes k-path centrality on the graph passed in constructor.
+     */
+    void run() override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_CENTRALITY_K_PATH_CENTRALITY_HPP_

package/vendor/include/networkit/centrality/KadabraBetweenness.hpp

@@ -0,0 +1,242 @@
+/*
+ * KadabraBetweenness.hpp
+ *
+ * Created on: 18.07.2018
+ *    Authors: Eugenio Angriman <angrimae@hu-berlin.de>
+ *             Alexander van der Grinten <avdgrinten@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_CENTRALITY_KADABRA_BETWEENNESS_HPP_
+#define NETWORKIT_CENTRALITY_KADABRA_BETWEENNESS_HPP_
+
+#include <atomic>
+#include <memory>
+#include <random>
+#include <ranges>
+#include <vector>
+
+#include <networkit/auxiliary/SortedList.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/components/ConnectedComponents.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+class StateFrame {
+public:
+    StateFrame(const count size) { apx.assign(size, 0); };
+    count nPairs = 0;
+    count epoch = 0;
+    std::vector<count> apx;
+
+    void reset(count newEpoch) {
+        std::ranges::fill(apx, 0);
+        nPairs = 0;
+        epoch = newEpoch;
+    }
+};
+
+class Status {
+public:
+    Status(count k);
+    const count k;
+    std::vector<node> top;
+    std::vector<double> approxTop;
+    std::vector<bool> finished;
+    std::vector<double> bet;
+    std::vector<double> errL;
+    std::vector<double> errU;
+};
+
+class SpSampler {
+private:
+    const Graph &G;
+    const ConnectedComponents &cc;
+
+public:
+    SpSampler(const Graph &G, const ConnectedComponents &cc);
+    void randomPath(StateFrame *curFrame);
+    StateFrame *frame;
+    std::mt19937_64 rng;
+    std::uniform_int_distribution<node> distr;
+
+private:
+    std::vector<uint8_t> timestamp;
+    uint8_t globalTS = 1;
+    static constexpr uint8_t stampMask = 0x7F;
+    static constexpr uint8_t ballMask = 0x80;
+    std::vector<count> dist;
+    std::vector<count> nPaths;
+    std::vector<node> q;
+    std::vector<std::pair<node, node>> spEdges;
+
+    inline node randomNode() const;
+    void backtrackPath(node source, node target, node start);
+    void resetSampler(count endQ);
+    count getDegree(const Graph &graph, node y, bool useDegreeIn);
+};
+
+/**
+ * @ingroup centrality
+ */
+class KadabraBetweenness : public Algorithm {
+public:
+    // See EUROPAR'19 paper for the selection of these parameters.
+    unsigned int baseItersPerStep = 1000;
+    double itersPerStepExp = 1.33;
+
+    /**
+     * Approximation of the betweenness centrality and computation of the top-k
+     * nodes with highest betweenness centrality according to the algorithm
+     * described in Borassi M., and Natale E. (2016): KADABRA is an ADaptive
+     * Algorithm for Betweenness via Random Approximation.
+     * Parallel implementation by Van der Grinten A., Angriman E., and
+     * Meyerhenke H.: Parallel Adaptive Sampling with almost no
+     * Synchronization, Euro-Par 2019.
+     * https://link.springer.com/chapter/10.1007/978-3-030-29400-7_31
+     * ArXiv pre-print: https://arxiv.org/abs/1903.09422.
+     *
+     * If k = 0 the algorithm approximates the betweenness centrality of all
+     * vertices of the graph so that the scores are within an additive error @a
+     * err with probability at least (1 - @a delta). Otherwise, the algorithm
+     * computes the exact ranking of the top-k nodes with highest betweenness
+     * centrality. The algorithm relies on an adaptive random sampling technique
+     * of shortest paths and the number of samples in the worst case is w =
+     * ((log(D - 2) + log(2/delta))/err^2 samples, where D is the diameter of
+     * the graph. Thus, the worst-case performance is O(w * (|E| + |V|)), but
+     * performs better in practice.
+     *
+     * @param G The graph
+     * @param err Maximum additive error guaranteed when approximating the
+     * betweenness centrality of all nodes.
+     * @param delta probability that the values of the betweenness centrality
+     * are within the error guarantee.
+     * @param deterministic If true, the algorithm guarantees that the results of two different
+     * executions is the same for a fixed random seed, regardless of the number of threads. Note
+     * that this guarantee leads to increased computational and memory complexity. Default: false.
+     * @param k the number of top-k nodes to be computed. Set it to zero to
+     * approximate the betweenness centrality of all the nodes.
+     * @param unionSample algorithm parameter that is automatically chosen.
+     * @param startFactor algorithm parameter that is automatically chosen.
+     */
+    KadabraBetweenness(const Graph &G, double err = 0.01, double delta = 0.1,
+                       bool deterministic = false, count k = 0, count unionSample = 0,
+                       count startFactor = 100);
+
+    /**
+     * Executes the Kadabra algorithm.
+     */
+    void run() override;
+
+    /**
+     * @return The ranking of the nodes according to their approximated
+     * betweenness centrality.
+     */
+    std::vector<std::pair<node, double>> ranking() const;
+
+    /**
+     * @return Nodes of the graph sorted by their approximated betweenness
+     * centrality.
+     */
+    std::vector<node> topkNodesList() const {
+        assureFinished();
+        return topkNodes;
+    }
+
+    /**
+     * @return Sorted list of approximated betweenness centrality scores.
+     */
+    std::vector<double> topkScoresList() const {
+        assureFinished();
+        return topkScores;
+    }
+
+    /**
+     * @return Approximated betweenness centrality score of all the nodes of the
+     * graph.
+     */
+    std::vector<double> scores() const {
+        assureFinished();
+        return approxSum;
+    }
+
+    /**
+     * @return Total number of samples.
+     */
+    count getNumberOfIterations() const {
+        assureFinished();
+        return nPairs;
+    }
+
+    /**
+     * @return Upper bound to the number of samples.
+     */
+    double getOmega() const {
+        assureFinished();
+        return omega;
+    }
+
+    count maxAllocatedFrames() const {
+        assureFinished();
+        return *std::ranges::max_element(maxFrames);
+    }
+
+protected:
+    const Graph &G;
+    const double delta, err;
+    const bool deterministic;
+    const count k, startFactor;
+    count unionSample;
+    count nPairs;
+    const bool absolute;
+    double deltaLMinGuess, deltaUMinGuess, omega;
+    std::atomic<int32_t> epochToRead;
+    int32_t epochRead;
+    count seed0, seed1;
+    std::vector<count> maxFrames;
+
+    std::vector<node> topkNodes;
+    std::vector<double> topkScores;
+    std::vector<std::pair<node, double>> rankingVector;
+    std::vector<std::atomic<StateFrame *>> epochFinished;
+    std::vector<SpSampler> samplerVec;
+    std::unique_ptr<Aux::SortedList> top;
+    std::unique_ptr<ConnectedComponents> cc;
+
+    std::vector<double> approxSum;
+    std::vector<double> deltaLGuess;
+    std::vector<double> deltaUGuess;
+
+    std::atomic<bool> stop;
+
+    void init();
+    void computeDeltaGuess();
+    void computeBetErr(Status *status, std::vector<double> &bet, std::vector<double> &errL,
+                       std::vector<double> &errU) const;
+    bool computeFinished(Status *status) const;
+    void getStatus(Status *status, bool parallel = false) const;
+    void computeApproxParallel(const std::vector<StateFrame> &firstFrames);
+    double computeF(double btilde, count iterNum, double deltaL) const;
+    double computeG(double btilde, count iterNum, double deltaU) const;
+    void fillResult();
+    void checkConvergence(Status &status);
+
+    void fillPQ() {
+        for (count i = 0; i < G.upperNodeIdBound(); ++i) {
+            top->insert(i, approxSum[i]);
+        }
+    }
+};
+
+inline std::vector<std::pair<node, double>> KadabraBetweenness::ranking() const {
+    assureFinished();
+    std::vector<std::pair<node, double>> result(topkNodes.size());
+#pragma omp parallel for
+    for (omp_index i = 0; i < static_cast<omp_index>(result.size()); ++i) {
+        result[i] = std::make_pair(topkNodes[i], topkScores[i]);
+    }
+    return result;
+}
+} // namespace NetworKit
+
+#endif // NETWORKIT_CENTRALITY_KADABRA_BETWEENNESS_HPP_