@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/structures/LocalCommunity.hpp

@@ -0,0 +1,363 @@
+#ifndef NETWORKIT_STRUCTURES_LOCAL_COMMUNITY_HPP_
+#define NETWORKIT_STRUCTURES_LOCAL_COMMUNITY_HPP_
+
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * Class for maintaining some measures for a local community while expanding it.
+ *
+ * Depending on the template parameters, different values are maintained. By
+ * default, it stores the shell of the community (i.e., all external neighbors)
+ * and the volume and cut of the community. Further, for every node in the shell,
+ * the number of internal neighbors is maintained. Optionally, also the number of
+ * external neighbors can be maintained for every node in the shell (@a ShellMaintainsExtDeg).
+ * Additionally, also the boundary, i.e., all nodes in the community that have
+ * a neighbor in the shell are maintained (@a MaintainBoundary).
+ */
+template <bool ShellMaintainsExtDeg, bool MaintainBoundary = false, bool AllowRemoval = false>
+class LocalCommunity {
+    static_assert(!MaintainBoundary || ShellMaintainsExtDeg,
+                  "boundary cannot be maintained without maintaining the external degree");
+
+public:
+    template <typename ValueType, bool used>
+    struct OptionalValue {
+        ValueType &get() { throw std::runtime_error("Getting value that is missing"); }
+
+        const ValueType &get() const { throw std::runtime_error("Getting value that is missing"); }
+
+        ValueType &operator*() { throw std::runtime_error("Getting value that is missing"); }
+
+        const ValueType &operator*() const {
+            throw std::runtime_error("Getting value that is missing");
+        }
+
+        ValueType *operator->() { throw std::runtime_error("Getting value that is missing"); }
+
+        const ValueType *operator->() const {
+            throw std::runtime_error("Getting value that is missing");
+        }
+
+        void set(ValueType) { throw std::runtime_error("Setting value that is missing"); }
+
+        OptionalValue &operator+=(ValueType) {
+            throw std::runtime_error("Increasing value that is missing");
+        }
+
+        OptionalValue &operator-=(ValueType) {
+            throw std::runtime_error("Decreasing value that is missing");
+        }
+
+        OptionalValue(const ValueType &){};
+
+        OptionalValue(){};
+    };
+
+    template <typename ValueType>
+    struct OptionalValue<ValueType, true> {
+        ValueType &get() { return value; }
+
+        const ValueType &get() const { return value; }
+
+        ValueType &operator*() { return value; }
+
+        const ValueType &operator*() const { return value; }
+
+        ValueType *operator->() { return &value; }
+
+        const ValueType *operator->() const { return &value; }
+
+        void set(ValueType v) { value = v; }
+
+        template <typename SecondValue,
+                  typename std::enable_if<std::is_scalar<SecondValue>::value, int>::type = 0>
+        OptionalValue &operator+=(SecondValue v) {
+            value += v;
+            return *this;
+        }
+
+        template <typename SecondValue,
+                  typename std::enable_if<std::is_scalar<SecondValue>::value, int>::type = 0>
+        OptionalValue &operator-=(SecondValue v) {
+            value -= v;
+            return *this;
+        }
+
+        OptionalValue(const ValueType &v) : value(v){};
+
+        OptionalValue() : value(){};
+
+        ValueType value;
+    };
+
+    struct ShellInfo {
+        /**
+         * Number of neighbors in the community.
+         */
+        OptionalValue<double, true> intDeg;
+
+        /**
+         * Number of neighbors outside the community.
+         */
+        OptionalValue<double, ShellMaintainsExtDeg> extDeg;
+
+        /**
+         * Number of nodes in the boundary whose only outside neighbor is this node.
+         */
+        OptionalValue<count, MaintainBoundary> numExclusiveBoundaryMembers;
+
+        /**
+         * Calculate how much the boundary size would change if the node
+         * was added to the community.
+         */
+        int64_t boundaryChange() const {
+            int64_t boundary_diff = -1 * numExclusiveBoundaryMembers.get();
+
+            if (extDeg.get() > 0) {
+                boundary_diff += 1;
+            }
+
+            return boundary_diff;
+        }
+
+        ShellInfo() : intDeg(0), extDeg(0), numExclusiveBoundaryMembers(0) {}
+    };
+
+    struct CommunityInfo {
+        /**
+         * Number of neighbors in the community.
+         */
+        OptionalValue<double, AllowRemoval> intDeg;
+
+        /**
+         * Number of neighbors outside the community.
+         */
+        OptionalValue<double, ShellMaintainsExtDeg && AllowRemoval> extDeg;
+
+        /**
+         * The only neighbor outside the community if there is only one.
+         */
+        OptionalValue<node, MaintainBoundary && AllowRemoval> exclusiveOutsideNeighbor;
+
+        /**
+         * The number of neighbors that have no internal neighbors.
+         */
+        OptionalValue<count, MaintainBoundary && AllowRemoval> numFullyInternalNeighbors;
+
+        /**
+         * Calculate how much the boundary size would change if the node
+         * was removed from the community.
+         */
+        int64_t boundaryChange() const {
+            int64_t boundary_diff = numFullyInternalNeighbors.get();
+
+            if (extDeg.get() > 0) {
+                boundary_diff -= 1;
+            }
+
+            return boundary_diff;
+        }
+
+        CommunityInfo()
+            : intDeg(0), extDeg(0), exclusiveOutsideNeighbor(none), numFullyInternalNeighbors(0) {}
+    };
+
+    /**
+     * Initialize an empty community for the given graph.
+     *
+     * @param G The graph.
+     */
+    LocalCommunity(const Graph &G);
+
+    /**
+     * Add the given node to the community.
+     *
+     * This needs O(deg(u)) time in expectation. If the boundary
+     * is maintained, the complexity can be higher but this is amortized
+     * if nodes are only added to the community.
+     *
+     * @param u The node to add.
+     */
+    void addNode(node u);
+
+    /**
+     * Removes the given node form the community
+     *
+     * This needs O(deg(u)) time in expectation. If the boundary
+     * is maintained, the complexity can be higher but this is amortized
+     * if nodes are only added to the community.
+     *
+     * @param u The node to add.
+     */
+    void removeNode(node u);
+
+    /**
+     * Check if a given node @a u is in the community.
+     *
+     * @param u The node to check.
+     *
+     * @return If @a u is in the community.
+     */
+    bool contains(node u) const;
+
+    /**
+     * Return the community as a std::set<node>.
+     *
+     * @return The community as std::set<node>
+     */
+    std::set<node> toSet() const;
+
+    /**
+     * Execute a callback for every node in the shell.
+     *
+     * The complexity is linear in the size of the shell.
+     * The callback should accept a node and a ShellInfo
+     * object as parameters. Note that only the enabled
+     * properties of the ShellInfo object may be accessed.
+     *
+     * @param callback The callback to call.
+     */
+    template <typename F>
+    void forShellNodes(F callback) {
+        for (const auto &it : shell) {
+
+#ifdef NETWORKIT_SANITY_CHECKS
+#ifndef NDEBUG
+            auto intExtDeg = calculateIntExtDeg(it.first);
+            assert(*it.second.intDeg == intExtDeg.first);
+            if (ShellMaintainsExtDeg) {
+                assert(*it.second.extDeg == intExtDeg.second);
+            }
+
+            if (MaintainBoundary) {
+                int64_t boundary_diff_debug = 0;
+                bool v_in_boundary = false;
+                G->forNeighborsOf(it.first, [&](node x) {
+                    auto it = currentBoundary->find(x);
+                    if (it != currentBoundary->end()) {
+                        if (it->second == 1) {
+                            boundary_diff_debug -= 1;
+                        }
+                    } else if (!v_in_boundary) {
+                        boundary_diff_debug += 1;
+                        v_in_boundary = true;
+                    }
+                });
+
+                assert(it.second.boundaryChange() == boundary_diff_debug);
+            }
+#endif // NDEBUG
+#endif // NETWORKIT_SANITY_CHECKS
+
+            callback(it.first, it.second);
+        }
+    }
+
+    /**
+     * Execute a callback for every node in the community.
+     *
+     * The complexity is linear in the size of the community.
+     * The callback should accept a node and a CommunityInfo
+     * object as parameters. Note that only the enabled
+     * properties of the CommunityInfo object may be accessed.
+     *
+     * Note that unless AllowRemoval is set, the CommunityInfo object is empty.
+     *
+     * @param callback The callback to call.
+     */
+    template <typename F>
+    void forCommunityNodes(F callback) {
+        for (auto it = community.cbegin(); it != community.cend();) {
+            // advance the iterator so the current element may be deleted
+            const auto cit = it++;
+#ifdef NETWORKIT_SANITY_CHECKS
+#ifndef NDEBUG
+            if (AllowRemoval) {
+                auto intExtDeg = calculateIntExtDeg(cit->first);
+                assert(*cit->second.intDeg == intExtDeg.first);
+                if (ShellMaintainsExtDeg) {
+                    assert(*cit->second.extDeg == intExtDeg.second);
+                }
+
+                if (MaintainBoundary) {
+                    int64_t boundary_diff_debug = 0;
+                    bool v_in_boundary = false;
+                    G->forNeighborsOf(cit->first, [&](node x) {
+                        if (community.find(x) == community.end()) {
+                            if (!v_in_boundary) {
+                                boundary_diff_debug -= 1;
+                                v_in_boundary = true;
+                            }
+                        } else if (currentBoundary->find(x) == currentBoundary->end()) {
+                            boundary_diff_debug += 1;
+                        }
+                    });
+
+                    assert(cit->second.boundaryChange() == boundary_diff_debug);
+                }
+            }
+#endif // NDEBUG
+#endif // NETWORKIT_SANITY_CHECKS
+
+            callback(cit->first, cit->second);
+        }
+    }
+
+    /**
+     * Get the size of the community.
+     *
+     * @return The size of the community.
+     */
+    size_t size() const { return community.size(); }
+
+    /**
+     * Get the internal edge weight.
+     * This is the sum of the weights of all internal edges, i.e.,
+     * the weight of every internal edge is counted once.
+     *
+     * @return The internal edge weight of the community.
+     */
+    double internalEdgeWeight() const { return intWeight; }
+
+    /**
+     * Get the cut of the community.
+     *
+     * @return The cut of the community.
+     */
+    double cut() const { return extWeight; }
+
+    /**
+     * Get the size of the boundary of the community.
+     *
+     * @return The size of the boundary.
+     */
+    count boundarySize() const { return currentBoundary->size(); }
+
+private:
+    const Graph *G;
+    std::unordered_map<node, CommunityInfo> community;
+    std::unordered_map<node, ShellInfo> shell;
+    double intWeight;
+    double extWeight;
+    OptionalValue<std::unordered_map<node, count>, MaintainBoundary> currentBoundary;
+
+    // The boundary is defined as all nodes of C that have a neighbor not in C
+    std::unordered_set<node> calculateBoundary();
+
+    /**
+     * internal and external weighted degree of a node with respect to the community
+     */
+    std::pair<double, double> calculateIntExtDeg(node v);
+
+    std::pair<double, double> calculateVolumeCut();
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_STRUCTURES_LOCAL_COMMUNITY_HPP_

package/vendor/include/networkit/structures/Partition.hpp

@@ -0,0 +1,335 @@
+/*
+ * Partition.hpp
+ *
+ *  Created on: 03.10.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_STRUCTURES_PARTITION_HPP_
+#define NETWORKIT_STRUCTURES_PARTITION_HPP_
+
+#include <cassert>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup structures
+ * Implements a partition of a set, i.e. a subdivision of the
+ * set into disjoint subsets.
+ */
+class Partition final {
+
+public:
+    Partition();
+
+    /**
+     * Create a new partition data structure for @a z elements.
+     *
+     * @param[in] z maximum index
+     */
+    Partition(index z);
+
+    /**
+     * Create a new partition data structure for @a z elements. Initialize each
+     * entry to the default value. WARNING: this circumvents the standard
+     * interface and may leave the object in an inconsistent state. Use only in
+     * exceptional cases.
+     *
+     * @param[in] z maximum index
+     * @param[in] defaultValue
+     */
+    Partition(index z, index defaultValue);
+
+    Partition(const std::vector<index> &data);
+
+    /* Updates the maximum index of the partition to @a newZ and sets all its
+     * values to @a defaultValue.
+     *
+     * @param[in] newZ New maximum index of the partition. @param[in]
+     * defaultValue Default value of all the elements in the partition.
+     */
+    void reset(index newZ, index defaultValue) {
+        data.clear();
+        data.resize(newZ, defaultValue);
+        z = newZ;
+        omega = 0;
+    }
+
+    /**
+     *  Index operator.
+     *
+     *  @param[in] e an element
+     */
+    inline index &operator[](index e) { return this->data[e]; }
+
+    /**
+     * Index operator for const instances of this class.
+     *
+     * @param[in] e an element
+     */
+    inline const index &operator[](index e) const { return this->data[e]; }
+
+    /**
+     * Get the set (id) in which the element @a e is contained.
+     *
+     * @param e Index of element.
+     * @return The index of the set in which @a e is contained.
+     */
+    inline index subsetOf(index e) const {
+        assert(e < this->numberOfElements());
+        return this->data[e];
+    }
+
+    /**
+     * Extend the data structure and create a slot for one more element.
+     * Initializes the entry to none and returns the index of the entry.
+     */
+    inline index extend() {
+        data.push_back(none);
+        z++;
+        assert(z == data.size()); //(data.size() - 1)
+        return z - 1;
+    }
+
+    /**
+     * Removes the entry for the given element
+     * by setting it to none.
+     */
+    inline void remove(index e) {
+        assert(e < z);
+        data[e] = none;
+    }
+
+    /**
+     * Add a (previously unassigned) element @a e to the set @a s.
+     *
+     * @param s The index of the subset.
+     * @param e The element to add.
+     */
+    inline void addToSubset(index s, index e) {
+        assert(data[e] == none); // guarantee that element was unassigned
+        assert(s <= omega);      // do not create new subset ids
+        data[e] = s;
+    }
+
+    /**
+     * Move the (previously assigned) element @a e to the set @a s.
+     *
+     * @param s The index of the subset.
+     * @param e The element to move.
+     */
+    inline void moveToSubset(index s, index e) {
+        assert(this->contains(e));
+        assert(s <= omega); // do not create new subset ids
+        data[e] = s;
+    }
+
+    /**
+     * Creates a singleton set containing the element @a e.
+     *
+     * @param e The index of the element.
+     */
+    inline void toSingleton(index e) { data[e] = newSubsetId(); }
+
+    /**
+     * Assigns every element to a singleton set.
+     * Set id is equal to element id.
+     */
+    void allToSingletons();
+
+    /**
+     * Assigns every element to the same subset.
+     * Set id is equal to zero.
+     */
+    void allToOnePartition();
+
+    /**
+     * Assigns the elements from both sets to a new set and returns the id of it.
+     *
+     * @param s Set to merge.
+     * @param t Set to merge.
+     * @return Id of newly created set.
+     */
+    index mergeSubsets(index s, index t);
+
+    /**
+     * Sets an upper bound for the subset ids that CAN be assigned.
+     *
+     * @param[in] upper highest assigned subset ID + 1
+     */
+    inline void setUpperBound(index upper) { this->omega = upper - 1; }
+
+    /**
+     * Return an upper bound for the subset ids that have been assigned.
+     * (This is the maximum id + 1.)
+     *
+     * @return The upper bound.
+     */
+    inline index upperBound() const { return omega + 1; }
+
+    /**
+     * Get a lower bound for the subset ids that have been assigned.
+     *
+     * @return The lower bound.
+     */
+    inline index lowerBound() const { return 0; }
+
+    /**
+     * Change subset IDs to be consecutive, starting at 0.
+     *
+     * @param useTurbo Default: false. If set to true, a vector instead of a map to assign new ids
+     * which results in a shorter running time but possibly a large space overhead.
+     */
+    void compact(bool useTurbo = false);
+
+    /**
+     * Check if partition assigns a valid subset to the element @a e.
+     *
+     * @param e The element.
+     * @return @c true if the assigned subset is valid, @c false otherwise.
+     */
+    inline bool contains(index e) const {
+        // e is in the element index range and the entry is not empty
+        return (e < z) && (data[e] != none);
+    }
+
+    /**
+     * Check if two elements @a e1 and @a e2 belong to the same subset.
+     *
+     * @param e1 Element.
+     * @param e2 Element.
+     * @return @c true if @a e1 and @a e2 belong to same subset, @c false otherwise.
+     */
+    inline bool inSameSubset(index e1, index e2) const {
+        assert(data[e1] != none);
+        assert(data[e2] != none);
+        return data[e1] == data[e2];
+    }
+
+    /**
+     * Get a list of subset sizes. Indices do not necessarily correspond to subset ids.
+     *
+     * @return A vector of subset sizes.
+     */
+    std::vector<count> subsetSizes() const;
+
+    /**
+     * Get a map from subset id to size of the subset.
+     *
+     * @return A map from subset id to size of the subset.
+     */
+    std::map<index, count> subsetSizeMap() const;
+
+    /**
+     * Get the members of the subset @a s.
+     *
+     * @param s The subset.
+     * @return A set containing the members of @a s.
+     */
+    std::set<index> getMembers(index s) const;
+
+    /**
+     * @return number of elements in the partition.
+     */
+    inline count numberOfElements() const {
+        return z; // z is the maximum element id
+    }
+
+    /**
+     * Get the current number of sets in this partition.
+     *
+     * @return The current number of sets.
+     */
+    count numberOfSubsets() const;
+
+    /**
+     * Get the actual vector representing the partition data structure.
+     *
+     * @return vector containing information about partitions.
+     */
+    const std::vector<index> &getVector() const;
+
+    /**
+     * @return the subsets of the partition as a set of sets.
+     */
+    std::set<std::set<index>> getSubsets() const;
+
+    /**
+     * Get the ids of nonempty subsets.
+     *
+     * @return A set of ids of nonempty subsets.
+     */
+    std::set<index> getSubsetIds() const;
+
+    /**
+     * Set a human-readable identifier @a name for the instance.
+     *
+     * @param name The name.
+     */
+    inline void setName(std::string name) { this->name = std::move(name); }
+
+    /**
+     * Get the human-readable identifier.
+     *
+     * @return The name of this partition.
+     */
+    inline std::string getName() const { return this->name; }
+
+    /**
+     * Iterate over all entries (node, cluster id) and execute callback function @a func (lambda
+     * closure).
+     *
+     * @param func Takes parameters <code>(node, index)</code>
+     */
+    template <typename Callback>
+    void forEntries(Callback func) const;
+
+    /**
+     * Iterate over all entries (node, cluster id) in parallel and execute callback function @a
+     * handle (lambda closure).
+     *
+     * @param handle Takes parameters <code>(node, index)</code>
+     */
+    template <typename Callback>
+    void parallelForEntries(Callback handle) const;
+
+private:
+    index z;                 //!< maximum element index that can be mapped
+    index omega;             //!< maximum subset index ever assigned
+    std::vector<index> data; //!< data container, indexed by element index, containing subset index
+    std::string name;
+
+    /**
+     * Allocates and returns a new subset id.
+     */
+    inline index newSubsetId() {
+        index s = ++omega;
+        return s;
+    }
+};
+
+template <typename Callback>
+inline void Partition::forEntries(Callback handle) const {
+    for (index e = 0; e < this->z; e++) {
+        handle(e, data[e]);
+    }
+}
+
+template <typename Callback>
+inline void Partition::parallelForEntries(Callback handle) const {
+#pragma omp parallel for
+    for (omp_index e = 0; e < static_cast<omp_index>(this->z); e++) {
+        handle(e, this->data[e]);
+    }
+}
+
+} /* namespace NetworKit */
+
+#endif // NETWORKIT_STRUCTURES_PARTITION_HPP_