@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,112 +0,0 @@
-/*
- * ForestCentrality.hpp
- *
- *  Created on: 12.02.2020
- *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_CENTRALITY_FOREST_CENTRALITY_HPP_
-#define NETWORKIT_CENTRALITY_FOREST_CENTRALITY_HPP_
-
-#include <cmath>
-#include <functional>
-#include <omp.h>
-#include <random>
-#include <vector>
-
-#include <networkit/algebraic/Vector.hpp>
-#include <networkit/centrality/Centrality.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-// NOTE: Does not support multiple calls of run()
-class ForestCentrality final : public Centrality {
-
-public:
-    /**
-     * Approximates the forest closeness centrality of all the vertices of a graph by approximating
-     * the diagonal of the forest matrix of @a G. Every element of the diagonal is guaranteed to
-     * have a maximum absolute error of @a epsilon. Based on "New Approximation Algorithms for
-     * Forest Closeness Centrality - for Individual Vertices and Vertex Groups", van der Grinten et
-     * al, SDM 2021.
-     * The algorithm runs in two steps: (i) solving a linear system and (ii) sampling uniform
-     * spanning trees (USTs). The parameter @a kappa balances the tolerance of the linear sytem
-     * solver and the number of USTs to be sampled. A high value of @a kappa raises the tolerance
-     * (solver converges faster) but more USTs need to be sampled, vice versa for a low value of @a
-     * kappa. Note: the algorithm requires an augmented graph as input (see the reference paper for
-     * details). An augmented graphs can be generated with GraphTools::createAugmentedGraph.
-     *
-     * @param G The input graph. Must be an augmented graph (an augmented graph can be crated with
-     * GraphTools::createAugmentedGraph.
-     * @param root Root node of the augmented graph.
-     * @param epsilon Maximum absolute error of the elements in the diagonal.
-     * @param kappa Balances the tolerance of the linear system solver and the number of USTs to be
-     * sampled.
-     */
-    explicit ForestCentrality(const Graph &G, node root, double epsilon = 0.1, double kappa = 0.3);
-
-    /**
-     * Run the algorithm.
-     */
-    void run() override;
-
-    /**
-     * Return an epsilon-approximation of the diagonal of the forest matrix.
-     *
-     * @return Approximation of the diagonal of the forest matrix.
-     */
-    const std::vector<double> &getDiagonal() const {
-        assureFinished();
-        return diagonal;
-    }
-
-    /**
-     * Return the number of sampled USTs.
-     *
-     * @return Number of sampled USTs.
-     */
-    count getNumberOfSamples() const noexcept { return numberOfUSTs; }
-
-private:
-    node root;
-    const double epsilon, kappa, volG;
-    const count numberOfUSTs;
-
-    // Used to mark the status of each node, one vector per thread
-    std::vector<std::vector<uint8_t>> statusGlobal;
-
-    // Pointers to the parent of the UST, one vector per thread
-    std::vector<std::vector<node>> parentsGlobal;
-
-    // Nodes sorted by decreasing degree
-    std::vector<node> decDegree;
-
-    // Non-normalized approx effective resistance, one per thread.
-    std::vector<std::vector<count>> approxEffResistanceGlobal;
-
-    // Distributions for selecting random neighbors
-    std::vector<std::uniform_int_distribution<count>> uniformDistr;
-
-    // Solution of the linear system
-    Vector linearSysSol;
-
-    // Diagonal elements
-    std::vector<double> diagonal;
-
-    count computeNumberOfUSTs() const {
-        return count{4}
-               * static_cast<count>(std::ceil(
-                   std::log(2.0 * static_cast<double>(G.numberOfEdges()) * G.numberOfNodes())
-                   / (2.0 * epsilon * epsilon)));
-    }
-
-    void sampleUSTs();
-    void solveLinearSystem();
-    void computeDiagonal();
-    void computeScores();
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_CENTRALITY_FOREST_CENTRALITY_HPP_

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

@@ -1,225 +0,0 @@
-/* GedWalk.hpp
- *
- *  Created on: 18.6.2018
- *     Authors: Eugenio Angriman <angrimae@hu-berlin.de>
- *              Alexander van der Grinten <avdgrinten@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_CENTRALITY_GED_WALK_HPP_
-#define NETWORKIT_CENTRALITY_GED_WALK_HPP_
-
-#include <networkit/auxiliary/VectorComparator.hpp>
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-
-#include <tlx/container/d_ary_addressable_int_heap.hpp>
-
-namespace NetworKit {
-
-class GedWalk final : public Algorithm {
-
-    using walks = double;
-
-public:
-    enum GreedyStrategy {
-        LAZY,
-        STOCHASTIC,
-        lazy = LAZY, // this + following added for backwards compatibility
-        stochastic = STOCHASTIC
-    };
-
-    enum BoundStrategy {
-        NO,
-        SPECTRAL,
-        GEOMETRIC,
-        ADAPTIVE_GEOMETRIC,
-        no = NO, // this + following added for backwards compatibility
-        spectral = SPECTRAL,
-        geometric = GEOMETRIC,
-        adaptiveGeometric = ADAPTIVE_GEOMETRIC
-    };
-
-    double stocEpsilon = 0.1;
-
-private:
-    const Graph *G;
-    const count k;
-    const double epsilon;
-    double alpha;
-    const BoundStrategy boundStrategy;
-    GreedyStrategy greedyStrategy;
-    double spectralDelta;
-    double degOutMax;
-    double degInMax;
-    std::vector<double> alphas;
-
-    // Size of pathsIn / pathsOut and related vectors.
-    count allocatedLevels = 15;
-
-    double sigmaMax;
-
-    // Similar to gainScore, gainBound and gainW, but for the entire group.
-    // These values are always maintained exactly.
-    double groupScore; // Score of the group.
-    walks groupW;      // Number of walks on the last level.
-    walks groupBound;  // Upper bound on the score of the group.
-
-    walks graphW;
-
-    count nLevels = 2;
-    std::vector<node> group;
-    std::vector<unsigned char> inGroup;
-    std::vector<unsigned char> isExact;
-    std::vector<unsigned char> nodesToPick;
-    std::vector<std::vector<walks>> pathsIn, pathsOut;
-    std::vector<std::vector<walks>> pathsHit, pathsMiss;
-
-    // Unless isExact[x], these values might be upper bounds on the true values.
-    std::vector<double> gainScore; // Marginal score of the group.
-    std::vector<walks> gainW;      // Number of marginal walks on the last level.
-    std::vector<double> gainBound; // Upper bound on the marginal score.
-
-    struct EvaluationResult {
-        double score;
-        walks w;
-    };
-
-    tlx::d_ary_addressable_int_heap<node, 2, Aux::GreaterInVector<double>> scoreQ{gainScore},
-        boundQ{gainBound};
-
-    void init();
-    double computeGamma();
-    void estimateGains();
-    void computeMarginalGain(node z);
-    void maximizeGain();
-    bool separateNodes();
-    double computeSigmaMax() const;
-    void fillPQs();
-    void updateAlphas();
-    EvaluationResult evaluateGraph();
-    EvaluationResult evaluateGroup();
-
-public:
-    /**
-     * Finds a group of `k` vertices with at least ((1 - 1/e) * opt - epsilon) GedWalk centrality
-     * score, where opt is the highest possible score. The algorithm is based on the paper "Group
-     * Centrality Maximization for Large-scale Graphs", Angriman et al., ALENEX20. It implements two
-     * independent greedy strategies (lazy and stochastic). Furthermore, it allows to compute the
-     * GedWalk score of a given set of nodes.
-     *
-     * @param G A (weakly) connected graph.
-     * @param k The desired group size.
-     * @param epsilon Precision of the algorithm.
-     * @param alpha Exponent to compute the GedWalk score.
-     * @param bs Bound strategy to compute the GedWalk bounds, default: BoundStrategy::GEOMETRIC.
-     * @param gs Greedy strategy to be used (lazy or stochastic), default: GreedyStrategy::LAZY.
-     * @param spectralDelta Delta to be used for the spectral bound.
-     *
-     * Note: if the graph is weighted, all weights should be in (0, 1].
-     */
-    GedWalk(const Graph &G, count k = 1, double initEpsilon = 0.1, double alpha = -1.,
-            BoundStrategy bs = BoundStrategy::GEOMETRIC, GreedyStrategy gs = GreedyStrategy::LAZY,
-            double spectralDelta = 0.5);
-
-    /**
-     * Run the algorithm.
-     */
-    void run() override;
-
-    /**
-     * Return the approximate GedWalk score of the computed group.
-     *
-     * @return The approximate score of the computed group.
-     */
-    double getApproximateScore() const {
-        assureFinished();
-        return groupScore;
-    }
-
-    /**
-     * Return the GedWalk score of the input group.
-     *
-     * @param first/last The range that contains the input group.
-     * @param scoreEpsilon The precision of the score to be computed.
-     */
-    template <class InputIt>
-    double scoreOfGroup(InputIt first, InputIt last, double scoreEpsilon = .1);
-
-    /**
-     * Return the computed group.
-     *
-     * @return The computed group.
-     */
-    std::vector<node> groupMaxGedWalk() const {
-        assureFinished();
-        return group;
-    }
-
-    const std::vector<double> &boundOfMarginalGains() const { return gainBound; }
-};
-
-template <class InputIt>
-double GedWalk::scoreOfGroup(InputIt first, InputIt last, double scoreEpsilon) {
-    if (boundStrategy == BoundStrategy::SPECTRAL) {
-        assert(alpha * static_cast<double>(sigmaMax) < 1.);
-    } else if (boundStrategy == BoundStrategy::GEOMETRIC) {
-        assert(alpha * static_cast<double>(degInMax) < 1.);
-    } else {
-        assert(boundStrategy == BoundStrategy::ADAPTIVE_GEOMETRIC);
-        assert(alpha * static_cast<double>(degOutMax + degInMax) < 1.);
-    }
-
-    std::fill(pathsHit[0].begin(), pathsHit[0].end(), walks{0});
-    std::fill(pathsMiss[0].begin(), pathsMiss[0].end(), walks{1});
-    std::fill(inGroup.begin(), inGroup.end(), static_cast<unsigned char>(0));
-    while (first != last) {
-        const auto u = *first;
-        inGroup[u] = 1;
-        pathsHit[0][u] = 1.0;
-        pathsMiss[0][u] = 0.0;
-        ++first;
-    }
-
-    graphW = evaluateGraph().w;
-
-    do {
-        const auto result = evaluateGroup();
-        groupScore = result.score;
-        groupW = result.w;
-        if (boundStrategy == BoundStrategy::SPECTRAL) {
-            const double gamma =
-                std::sqrt(G->numberOfNodes()) * (sigmaMax / (1 - alpha * sigmaMax));
-            groupBound = result.score + alphas[nLevels + 1] * gamma * graphW;
-        } else if (boundStrategy == BoundStrategy::GEOMETRIC) {
-            const double gamma = (degInMax / (1 - alpha * degInMax));
-            groupBound = result.score + alphas[nLevels + 1] * gamma * graphW;
-        } else {
-            assert(boundStrategy == BoundStrategy::ADAPTIVE_GEOMETRIC);
-            groupBound = result.score + alphas[nLevels + 1] * computeGamma() * result.w;
-        }
-
-        DEBUG("score is ", groupScore, ", bound is ", groupBound);
-        if (groupBound < groupScore + scoreEpsilon)
-            return groupScore;
-
-        DEBUG("increasing path length to ", nLevels + 1);
-        if (nLevels + 1 >= allocatedLevels) {
-            DEBUG("allocating ", nLevels + 2, " GedWalk levels");
-            while (allocatedLevels < nLevels + 2) {
-                pathsIn.emplace_back((G->upperNodeIdBound()));
-                pathsOut.emplace_back((G->upperNodeIdBound()));
-                pathsHit.emplace_back((G->upperNodeIdBound()));
-                pathsMiss.emplace_back((G->upperNodeIdBound()));
-                ++allocatedLevels;
-            }
-
-            updateAlphas();
-        }
-
-        ++nLevels;
-        graphW = evaluateGraph().w;
-    } while (true);
-}
-
-} // namespace NetworKit
-#endif // NETWORKIT_CENTRALITY_GED_WALK_HPP_

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

@@ -1,115 +0,0 @@
-/*
- * GroupCloseness.hpp
- *
- *  Created on: 03.10.2016
- *      Author: elisabetta bergamini
- */
-
-#ifndef NETWORKIT_CENTRALITY_GROUP_CLOSENESS_HPP_
-#define NETWORKIT_CENTRALITY_GROUP_CLOSENESS_HPP_
-
-#include <numeric>
-#include <sstream>
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/BFS.hpp>
-#include <networkit/graph/Dijkstra.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup centrality
- */
-class GroupCloseness final : public Algorithm {
-public:
-    /**
-     * Finds the group of nodes with highest (group) closeness centrality.
-     * The algorithm is the one proposed in Bergamini et al., ALENEX 2018 and
-     * finds a solution that is a (1-1/e)-approximation of the optimum.
-     * The worst-case running time of this approach is quadratic, but usually
-     * much faster in practice.
-     *
-     * @param G An unweighted graph.
-     * @param k Size of the group of nodes
-     * @param H If equal 0, simply runs the algorithm proposed in Bergamini et
-     * al.. If > 0, interrupts all BFSs after H iterations (suggested for very
-     * large networks).
-     * @
-     */
-    GroupCloseness(const Graph &G, count k = 1, count H = 0);
-
-    /**
-     * Computes the group with maximum closeness on the graph passed in the
-     * constructor.
-     */
-    void run() override;
-
-    /**
-     * Returns group with maximum closeness.
-     */
-    std::vector<node> groupMaxCloseness();
-
-    /**
-     * Computes farness (i.e., inverse of the closeness) for a given group
-     * (stopping after H iterations if H > 0).
-     */
-    double computeFarness(const std::vector<node> &S,
-                          count H = std::numeric_limits<count>::max()) const;
-
-    /**
-     * Computes the score of a specific group.
-     */
-    double scoreOfGroup(const std::vector<node> &group) const;
-
-private:
-    edgeweight computeImprovement(node u, count h);
-    void updateDistances(node u);
-    const Graph *G;
-    count k = 1;
-    std::vector<count> d;
-    std::vector<std::vector<count>> d1Global;
-    std::vector<node> S;
-    count H = 0;
-
-    void checkGroup(const std::vector<node> &group) const;
-};
-
-inline std::vector<node> GroupCloseness::groupMaxCloseness() {
-    assureFinished();
-    return S;
-}
-
-inline void GroupCloseness::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 double GroupCloseness::scoreOfGroup(const std::vector<node> &group) const {
-    double sumDist = 0.;
-    if (G->isWeighted())
-        Traversal::DijkstraFrom(*G, group.begin(), group.end(),
-                                [&](node, edgeweight dist) { sumDist += dist; });
-    else
-        Traversal::BFSfrom(*G, group.begin(), group.end(),
-                           [&](node, count dist) { sumDist += static_cast<double>(dist); });
-
-    return sumDist > 0. ? ((double)G->upperNodeIdBound() - (double)group.size()) / sumDist : 0.;
-}
-} /* namespace NetworKit */
-#endif // NETWORKIT_CENTRALITY_GROUP_CLOSENESS_HPP_

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

@@ -1,78 +0,0 @@
-/*
- *  GroupClosenessGrowShrink.hpp
- *
- *  Created on: 19.12.2019
- *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
- */
-
-#ifndef NETWORKIT_CENTRALITY_GROUP_CLOSENESS_GROW_SHRINK_HPP_
-#define NETWORKIT_CENTRALITY_GROUP_CLOSENESS_GROW_SHRINK_HPP_
-
-#include <memory>
-#include <vector>
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-// pImpl
-namespace GroupClosenessGrowShrinkDetails {
-template <class>
-class GroupClosenessGrowShrinkImpl;
-} // namespace GroupClosenessGrowShrinkDetails
-
-class GroupClosenessGrowShrink final : public Algorithm {
-
-public:
-    GroupClosenessGrowShrink(const Graph &graph, const std::vector<node> &group,
-                             bool extended = false, count insertions = 0,
-                             count maxIterations = 100);
-    /**
-     * Finds a group of nodes with high group closeness centrality. This is the Grow-Shrink
-     * 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 graph.
-     * @param first Iterator for first node of initial group of nodes.
-     * @param last Iterator for last node of initial group of nodes.
-     * @param extended Set this parameter to true for the Extended Grow-Shrink algorithm (i.e.,
-     * vertex exchanges are not restricted to only neighbors of the group).
-     * @param insertions Number of consecutive node insertions and removal per iteration. Let this
-     * parameter to zero to use Diameter(G)/sqrt(k) nodes (where k is the size of the group).
-     * @param maxIterations Maximum number of iterations allowed.
-     */
-    template <class Iter>
-    GroupClosenessGrowShrink(const Graph &G, Iter first, Iter last, bool extended = false,
-                             count insertions = 0, count maxIterations = 100)
-        : GroupClosenessGrowShrink(G, std::vector<node>(first, last), extended, insertions,
-                                   maxIterations) {}
-
-    ~GroupClosenessGrowShrink() override;
-
-    /**
-     * Runs the algorithm.
-     */
-    void run() override;
-
-    /**
-     * Returns the computed group.
-     */
-    std::vector<node> groupMaxCloseness() const;
-
-    /**
-     * Returns the total number of iterations performed by the algorithm.
-     */
-    count numberOfIterations() const;
-
-private:
-    const Graph *G;
-    std::unique_ptr<GroupClosenessGrowShrinkDetails::GroupClosenessGrowShrinkImpl<edgeweight>>
-        weightedImpl;
-    std::unique_ptr<GroupClosenessGrowShrinkDetails::GroupClosenessGrowShrinkImpl<count>>
-        unweightedImpl;
-};
-} // namespace NetworKit
-
-#endif // NETWORKIT_CENTRALITY_GROUP_CLOSENESS_GROW_SHRINK_HPP_

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

@@ -1,77 +0,0 @@
-#ifndef NETWORKIT_CENTRALITY_GROUP_CLOSENESS_LOCAL_SEARCH_HPP_
-#define NETWORKIT_CENTRALITY_GROUP_CLOSENESS_LOCAL_SEARCH_HPP_
-
-#include <limits>
-#include <memory>
-#include <vector>
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-
-namespace NetworKit {
-
-class GroupClosenessLocalSearch final : public Algorithm {
-public:
-    /**
-     * Local search approximation algorithm for Group Closeness Maximization presented in
-     * "Group-Harmonic and Group-Closeness Maximization – Approximation and Engineering", Angriman
-     * et al., ALENEX 2021. The algorithm evaluates all possible swaps between a vertex in the group
-     * and the vertices outside, and performs a swap iff the decrement in farness is at least $$(1 -
-     * 1 / (k \\cdot (n - k)))$$, where $$k$$ is the number of vertices in the group. Thus,
-     * even in a best-case scenario the time complexity of this algorithm is $$O(n \\cdot k)$$. To
-     * keep the number of swaps low, it is recommended to use this algorithm as a refinement step of
-     * an already good solution computed by a faster algorithm e.g., greedy (GroupCloseness), or
-     * GrowShrink (GroupClosenessGrowShrink). In undirected graphs the approximation ratio is 1/5,
-     * on directed graphs it has not been demonstrated.
-     *
-     * @param G A graph.
-     * @param first, last A range that contains the initial group of nodes.
-     * @param runGrowShrink Whether or not to run the Grow-Shrink algorithm on the initial group.
-     * @param maxIterations Maximum number of swaps allowed. Prevents the algorithm from performing
-     * too many swaps by giving up the approximation guarantee.
-     */
-    template <class InputIt>
-    GroupClosenessLocalSearch(const Graph &G, InputIt first, InputIt last,
-                              bool runGrowShrink = true,
-                              count maxIterations = std::numeric_limits<count>::max())
-        : GroupClosenessLocalSearch(G, std::vector<node>(first, last), runGrowShrink,
-                                    maxIterations) {}
-
-    GroupClosenessLocalSearch(const Graph &G, const std::vector<node> &group,
-                              bool runGrowShrink = true,
-                              count maxIterations = std::numeric_limits<count>::max());
-
-    /**
-     * Runs the algorithm.
-     */
-    void run() override;
-
-    /**
-     * Returns the computed group.
-     */
-    std::vector<node> groupMaxCloseness() const;
-
-    /**
-     * Returns the number of iterations performed by the algorithm.
-     */
-    count numberOfIterations() const;
-
-    class GroupClosenessLocalSearchInterface : public Algorithm {
-    public:
-        template <class InputIt>
-        GroupClosenessLocalSearchInterface(InputIt first, InputIt last) : group(first, last) {}
-
-        std::unordered_set<node> group;
-        count nIterations;
-    };
-
-private:
-    const bool weighted;
-    // Is always one between GroupClosenessLocalSearchImpl<count/edgeweight>,
-    // see implementation.
-    std::unique_ptr<GroupClosenessLocalSearchInterface> impl;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_CENTRALITY_GROUP_CLOSENESS_LOCAL_SEARCH_HPP_