@ladybugmem/icebug 0.1.0 → 0.1.2

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

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

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

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

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

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

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