@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/distance/STSP.hpp

@@ -0,0 +1,193 @@
+/*
+ * STSP.hpp
+ *
+ *  Created on: 15.06.2019
+ *      Author: Eugenio Angriman <angrimae@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_DISTANCE_STSP_HPP_
+#define NETWORKIT_DISTANCE_STSP_HPP_
+
+#include <algorithm>
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/auxiliary/Log.hpp>
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup distance
+ * Abstract base class for source-target shortest path algorithms.
+ */
+class STSP : public Algorithm {
+
+public:
+    /**
+     * Creates the STSP class for a graph @a G, source node @a source, and
+     * target node @a target.
+     *
+     * @param G The graph.
+     * @param source The source node.
+     * @param target The target node.
+     * @param storePred If true, the algorithm will also store the predecessors
+     * and reconstruct a shortest path from @a source and @a target.
+     */
+    STSP(const Graph &G, node source, node target, bool storePred = true)
+        : G(&G), source(source), target(target), storePred(storePred) {
+        if (!G.hasNode(source))
+            throw std::runtime_error("Error: source node not in the graph!");
+        if (!G.hasNode(target))
+            throw std::runtime_error("Error: target node not in the graph!");
+        if (source == target)
+            WARN("Source and target nodes are equal!");
+    }
+
+    /**
+     * Creates the STSP class for a graph @a G, source node @a source, and
+     * multiple target nodes.
+     *
+     * @param G The graph.
+     * @param source The source node.
+     * @param targetsFirst,targetsLast Range of target nodes.
+     */
+    template <class InputIt>
+    STSP(const Graph &G, node source, InputIt targetsFirst, InputIt targetsLast)
+        : G(&G), source(source), targets(targetsFirst, targetsLast), storePred(false) {
+        if (!G.hasNode(source))
+            throw std::runtime_error("Error: source node not in the graph!");
+        if (!std::all_of(targetsFirst, targetsLast, [&G](node u) { return G.hasNode(u); }))
+            throw std::runtime_error("Error: target node not in the graph!");
+    }
+
+    /**
+     * Returns a shortest path from the source node to the target node (without
+     * including them). Note: the shortest path can be constructed only if the
+     * algorithm is executed with @a storePred set to true.
+     *
+     * @return A shortest path from the @a source to @a target.
+     */
+    virtual std::vector<node> getPath() const {
+        checkStorePredecessors();
+        assureFinished();
+        return path;
+    }
+
+    /**
+     * Returns the predecessor nodes from the @a target to the source. Note:
+     * predecessors are stored only if the algorithm is executed with @a
+     * storePred set to true.
+     *
+     * @return The list of predecessors from @a target to @a source.
+     */
+    const std::vector<node> &getPredecessors() const {
+        checkStorePredecessors();
+        assureFinished();
+        return pred;
+    }
+
+    /**
+     * If the target is a single node: returns the distance from the source node to the target
+     * node.
+     * @return The distance from source to the target node.
+     */
+    edgeweight getDistance() const {
+        assureFinished();
+        return distance;
+    }
+
+    /**
+     * In case of multiple target nodes: returns the distance from the source node to the target
+     * nodes.
+     * @return Distances from the source to the target nodes.
+     */
+    const std::vector<edgeweight> &getDistances() const {
+        assureFinished();
+        return distances;
+    }
+
+    /**
+     * Sets the source node.
+     *
+     * @param newSource The new source node.
+     */
+    void setSource(node newSource) {
+        assert(G->hasNode(newSource));
+        source = newSource;
+    }
+
+    /**
+     * Sets the target node.
+     *
+     * @param newTarget The new target node.
+     */
+    void setTarget(node newTarget) {
+        assert(G->hasNode(newTarget));
+        target = newTarget;
+        targets.clear();
+    }
+
+    /**
+     * Sets the target nodes.
+     *
+     * @param targetsFirst,targetsLast Range of target nodes.
+     */
+    template <class InputIt>
+    void setTargets(InputIt targetsFirst, InputIt targetsLast) {
+        assert(std::all_of(targetsFirst, targetsLast, [&](auto u) { return G->hasNode(u); }));
+        targets.assign(targetsFirst, targetsLast);
+    }
+
+    /**
+     * Returns the <node, index> map from target nodes to their index in the vector
+     * returned by STSP::getDistances().
+     *
+     * @return Map from target nodes to their index in the vector returned by STSP::getDistances().
+     */
+    const std::unordered_map<node, index> &getTargetIndexMap() const {
+        assureFinished();
+        return targetIdx;
+    }
+
+protected:
+    const Graph *G;
+    node source = none, target = none;
+    std::vector<node> targets;
+    const bool storePred;
+    std::vector<node> pred, path;
+
+    edgeweight distance;
+    std::vector<edgeweight> distances;
+    std::unordered_map<node, index> targetIdx;
+
+    // Builds a source-target shortest path using the predecessors
+    void buildPath();
+
+    void checkStorePredecessors() const {
+        if (!storePred)
+            WARN("Predecessors not stored.");
+    }
+
+    void init() {
+        hasRun = false;
+        if (storePred)
+            pred.resize(G->upperNodeIdBound());
+    }
+};
+
+inline void STSP::buildPath() {
+    path.clear();
+    node t = target;
+    while (pred[t] != source) {
+        path.push_back(pred[t]);
+        t = pred[t];
+    }
+    std::ranges::reverse(path);
+}
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_DISTANCE_STSP_HPP_

package/vendor/include/networkit/distance/Volume.hpp

@@ -0,0 +1,66 @@
+/*
+ * Volume.hpp
+ *
+ * Created on: July 7, 2018
+ * Author: Franz-Benjamin Mocnik <mail@mocnik-science.net>
+ */
+
+#ifndef NETWORKIT_DISTANCE_VOLUME_HPP_
+#define NETWORKIT_DISTANCE_VOLUME_HPP_
+
+#include <unordered_map>
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup volume
+ */
+class Volume {
+private:
+    /**
+     * For a given node n, the nodes within distance r are returned together with
+     * their distance to node n.
+     */
+    static std::unordered_map<node, double> nodesWithinDistance(const Graph &G, double r, node n);
+
+public:
+    /**
+     * Number of nodes within a given radius; average for many nodes
+     *
+     * Please find further information about the volume and its meaning in the
+     * following publication:
+     *
+     * Franz-Benjamin Mocnik: "The Polynomial Volume Law of Complex Networks in
+     * the Context of Local and Global Optimization", Scientific Reports 8(11274)
+     * 2018. doi: 10.1038/s41598-018-29131-0
+     *
+     * @param G  the graph
+     * @param r  the radius
+     * @param samples	the number of samples
+     *
+     **/
+    static double volume(const Graph &G, double r, count samples);
+
+    /**
+     * Number of nodes within different given radii; average for many nodes
+     *
+     * Please find further information about the volume and its meaning in the
+     * following publication:
+     *
+     * Franz-Benjamin Mocnik: "The Polynomial Volume Law of Complex Networks in
+     * the Context of Local and Global Optimization", Scientific Reports 8(11274)
+     * 2018. doi: 10.1038/s41598-018-29131-0
+     *
+     * @param G  the graph
+     * @param rs  the radii
+     * @param samples	the number of samples
+     *
+     **/
+    static std::vector<double> volume(const Graph &G, std::vector<double> rs, count samples);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DISTANCE_VOLUME_HPP_

package/vendor/include/networkit/dynamics/DGSStreamParser.hpp

@@ -0,0 +1,40 @@
+/*
+ * DGSStreamParser.hpp
+ *
+ *  Created on: 23.12.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DYNAMICS_DGS_STREAM_PARSER_HPP_
+#define NETWORKIT_DYNAMICS_DGS_STREAM_PARSER_HPP_
+
+#include <fstream>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <networkit/dynamics/GraphEvent.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup dynamics
+ */
+class DGSStreamParser final {
+
+public:
+    DGSStreamParser(std::string_view path, bool mapped = true, node baseIndex = 0);
+
+    std::vector<GraphEvent> getStream();
+
+private:
+    std::ifstream dgsFile;
+    bool mapped;
+    std::map<std::string, node> key2id;
+    node baseIndex;
+    node nextNode;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DYNAMICS_DGS_STREAM_PARSER_HPP_

package/vendor/include/networkit/dynamics/DGSWriter.hpp

@@ -0,0 +1,30 @@
+/*
+ * DGSWriter.hpp
+ *
+ *  Created on: 14.01.2014
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DYNAMICS_DGS_WRITER_HPP_
+#define NETWORKIT_DYNAMICS_DGS_WRITER_HPP_
+
+#include <string>
+#include <vector>
+
+#include <networkit/dynamics/GraphEvent.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup dynamics
+ */
+class DGSWriter final {
+public:
+    DGSWriter() = default;
+
+    void write(std::vector<GraphEvent> &stream, std::string_view path);
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DYNAMICS_DGS_WRITER_HPP_

package/vendor/include/networkit/dynamics/GraphDifference.hpp

@@ -0,0 +1,110 @@
+#ifndef NETWORKIT_DYNAMICS_GRAPH_DIFFERENCE_HPP_
+#define NETWORKIT_DYNAMICS_GRAPH_DIFFERENCE_HPP_
+
+#include <networkit/base/Algorithm.hpp>
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * Calculate the edge difference between two graphs.
+ *
+ * This calculates which graph edge additions or edge removals are
+ * necessary to transform one given graph into another given graph.
+ *
+ * Both graphs need to have the same node set, directed graphs are not
+ * supported currently.
+ *
+ * Note that edge weight differences are not detected but edge
+ * addition events set the correct edge weight.
+ */
+class GraphDifference final : public Algorithm {
+public:
+    /**
+     * Construct the edge edit difference with two graphs to compare.
+     *
+     * @param G1 The first graph to compare.
+     * @param G2 The second graph to compare.
+     */
+    GraphDifference(const Graph &G1, const Graph &G2);
+
+    /**
+     * Execute the algorithm and compute the difference.
+     */
+    void run() override;
+
+    /**
+     * Get the required edits.
+     *
+     * @return A vector of graph events.
+     */
+    const std::vector<GraphEvent> &getEdits() const;
+
+    /**
+     * Get the required number of edits.
+     *
+     * This is only the number of actual changes.
+     * In order to get correct node ids, more edits might be generated.
+     *
+     * @return The number of edits.
+     */
+    count getNumberOfEdits() const;
+
+    /**
+     * Get the required number of node additions.
+     *
+     * @return The number of node additions.
+     */
+    count getNumberOfNodeAdditions() const;
+
+    /**
+     * Get the required number of node removals.
+     *
+     * @return The number of node removals.
+     */
+    count getNumberOfNodeRemovals() const;
+
+    /**
+     * Get the required number of node restorations.
+     *
+     * @return The number of node restorations.
+     */
+    count getNumberOfNodeRestorations() const;
+
+    /**
+     * Get the required number of edge additions.
+     *
+     * @return The number of edge additions.
+     */
+    count getNumberOfEdgeAdditions() const;
+
+    /**
+     * Get the required number of edge removals.
+     *
+     * @return The number of edge removals.
+     */
+    count getNumberOfEdgeRemovals() const;
+
+    /**
+     * Get the required number of edge weight updates.
+     *
+     * @return The number of edge weight updates.
+     */
+    count getNumberOfEdgeWeightUpdates() const;
+
+private:
+    const Graph *G1, *G2;
+    std::vector<GraphEvent> edits;
+    count numEdits;
+    count numNodeAdditions;
+    count numNodeRemovals;
+    count numNodeRestorations;
+    count numEdgeAdditions;
+    count numEdgeRemovals;
+    count numWeightUpdates;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_DYNAMICS_GRAPH_DIFFERENCE_HPP_

package/vendor/include/networkit/dynamics/GraphEvent.hpp

@@ -0,0 +1,55 @@
+/*
+ * GraphEvent.hpp
+ *
+ *  Created on: 02.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DYNAMICS_GRAPH_EVENT_HPP_
+#define NETWORKIT_DYNAMICS_GRAPH_EVENT_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup dynamics
+ */
+class GraphEvent final {
+
+public:
+    enum Type {
+        NODE_ADDITION,
+        NODE_REMOVAL,
+        NODE_RESTORATION,
+        EDGE_ADDITION,
+        EDGE_REMOVAL,
+        EDGE_WEIGHT_UPDATE,
+        EDGE_WEIGHT_INCREMENT,
+        TIME_STEP
+    };
+
+    Type type;    //!< type of graph event
+    node u;       //!< first node parameter
+    node v;       //!< second node parameter
+    edgeweight w; //!< edge weight parameter
+
+    GraphEvent() = default;
+
+    GraphEvent(Type type, node u = none, node v = none, edgeweight w = defaultEdgeWeight);
+
+    bool operator==(const GraphEvent &rhs) const noexcept;
+    bool operator!=(const GraphEvent &rhs) const noexcept;
+    friend bool operator<(const GraphEvent &a, const GraphEvent &b) noexcept;
+    friend bool operator>(const GraphEvent &a, const GraphEvent &b) noexcept;
+    bool operator<=(const GraphEvent &rhs) const noexcept;
+    bool operator>=(const GraphEvent &rhs) const noexcept;
+
+    /**
+     * Return string representation.
+     */
+    std::string toString() const;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DYNAMICS_GRAPH_EVENT_HPP_

package/vendor/include/networkit/dynamics/GraphEventHandler.hpp

@@ -0,0 +1,39 @@
+/*
+ * GraphEventHandler.hpp
+ *
+ *  Created on: 02.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DYNAMICS_GRAPH_EVENT_HANDLER_HPP_
+#define NETWORKIT_DYNAMICS_GRAPH_EVENT_HANDLER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup dynamics
+ */
+class GraphEventHandler {
+
+public:
+    virtual void onNodeAddition(node u) = 0;
+
+    virtual void onNodeRemoval(node u) = 0;
+
+    virtual void onNodeRestoration(node u) = 0;
+
+    virtual void onEdgeAddition(node u, node v, edgeweight w = 1.0) = 0;
+
+    virtual void onEdgeRemoval(node u, node v, edgeweight w = 1.0) = 0;
+
+    virtual void onWeightUpdate(node u, node v, edgeweight wOld, edgeweight wNew) = 0;
+
+    virtual void onWeightIncrement(node u, node v, edgeweight wOld, edgeweight delta) = 0;
+
+    virtual void onTimeStep() = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DYNAMICS_GRAPH_EVENT_HANDLER_HPP_

package/vendor/include/networkit/dynamics/GraphEventProxy.hpp

@@ -0,0 +1,55 @@
+/*
+ * GraphEventProxy.hpp
+ *
+ *  Created on: 03.04.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DYNAMICS_GRAPH_EVENT_PROXY_HPP_
+#define NETWORKIT_DYNAMICS_GRAPH_EVENT_PROXY_HPP_
+
+#include <networkit/dynamics/GraphEventHandler.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup dynamics
+ * This class enables the observer pattern for dynamic graphs: It has the same modifiers as a Graph
+ * object. When these modifiers are called, they are also called on the underlying graphs. Also, all
+ * registered observers (type GraphEventHandler) are notified.
+ */
+class GraphEventProxy final {
+
+private:
+    std::vector<GraphEventHandler *> observers;
+
+public:
+    GraphW *G;
+
+    GraphEventProxy(); // nullary constructor needed for python interface
+
+    GraphEventProxy(GraphW &G);
+
+    void registerObserver(GraphEventHandler *observer);
+
+    node addNode();
+
+    void removeNode(node u);
+
+    void restoreNode(node u);
+
+    void addEdge(node u, node v, edgeweight weight = defaultEdgeWeight);
+
+    void removeEdge(node u, node v);
+
+    void setWeight(node u, node v, edgeweight w);
+
+    void incrementWeight(node u, node v, edgeweight delta);
+
+    void timeStep();
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_DYNAMICS_GRAPH_EVENT_PROXY_HPP_

package/vendor/include/networkit/dynamics/GraphUpdater.hpp

@@ -0,0 +1,38 @@
+/*
+ * GraphUpdater.hpp
+ *
+ *  Created on: 27.12.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_DYNAMICS_GRAPH_UPDATER_HPP_
+#define NETWORKIT_DYNAMICS_GRAPH_UPDATER_HPP_
+
+#include <networkit/dynamics/GraphEvent.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup dynamics
+ */
+class GraphUpdater final {
+
+public:
+    GraphUpdater(GraphW &G);
+
+    void update(const std::vector<GraphEvent> &stream);
+
+    const std::vector<std::pair<count, count>> &getSizeTimeline() const;
+
+    static bool compare(GraphEvent a, GraphEvent b);
+    static bool equal(GraphEvent a, GraphEvent b);
+
+private:
+    GraphW *G;
+    std::vector<std::pair<count, count>> size;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_DYNAMICS_GRAPH_UPDATER_HPP_

package/vendor/include/networkit/edgescores/ChibaNishizekiQuadrangleEdgeScore.hpp

@@ -0,0 +1,26 @@
+/*
+ * ChibaNishizekiQuadrangleEdgeScore.hpp
+ *
+ *  Created on: 18.11.2014
+ *      Author: Michael Hamann, Gerd Lindner
+ */
+
+#ifndef NETWORKIT_EDGESCORES_CHIBA_NISHIZEKI_QUADRANGLE_EDGE_SCORE_HPP_
+#define NETWORKIT_EDGESCORES_CHIBA_NISHIZEKI_QUADRANGLE_EDGE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+
+namespace NetworKit {
+
+class ChibaNishizekiQuadrangleEdgeScore final : public EdgeScore<count> {
+
+public:
+    ChibaNishizekiQuadrangleEdgeScore(const Graph &G);
+    count score(edgeid eid) override;
+    count score(node u, node v) override;
+    void run() override;
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_EDGESCORES_CHIBA_NISHIZEKI_QUADRANGLE_EDGE_SCORE_HPP_

package/vendor/include/networkit/edgescores/ChibaNishizekiTriangleEdgeScore.hpp

@@ -0,0 +1,33 @@
+/*
+ * ChibaNishizekiTriangleEdgeScore.hpp
+ *
+ *  Created on: 22.05.2014
+ *      Author: Gerd Lindner
+ */
+
+#ifndef NETWORKIT_EDGESCORES_CHIBA_NISHIZEKI_TRIANGLE_EDGE_SCORE_HPP_
+#define NETWORKIT_EDGESCORES_CHIBA_NISHIZEKI_TRIANGLE_EDGE_SCORE_HPP_
+
+#include <networkit/edgescores/EdgeScore.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * An implementation of the triangle counting algorithm by Chiba/Nishizeki.
+ *
+ * @deprecated Use TriangleEdgeScore instead which is parallelized and has a similar performance
+ * even in the sequential case.
+ */
+class ChibaNishizekiTriangleEdgeScore final : public EdgeScore<count> {
+
+public:
+    ChibaNishizekiTriangleEdgeScore(const Graph &G);
+    count score(edgeid eid) override;
+    count score(node u, node v) override;
+    void run() override;
+};
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_EDGESCORES_CHIBA_NISHIZEKI_TRIANGLE_EDGE_SCORE_HPP_