@ladybugmem/icebug 0.1.0 → 0.1.1

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

@@ -1,66 +0,0 @@
-/*
- * UnionFind.hpp
- *
- *  Created on: 11.08.2014
- *      Author: Marcel Radermacher
- *      Changed a bit by Henning Meyerhenke to reflect union by rank and path compression
- *        as taught in "Algorithms 1"
- */
-
-#ifndef NETWORKIT_STRUCTURES_UNION_FIND_HPP_
-#define NETWORKIT_STRUCTURES_UNION_FIND_HPP_
-
-#include <vector>
-
-#include <networkit/Globals.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup structures
- * Implements the Union Find data structure to maintain disjoint sets efficiently.
- * Uses path compression and union by rank to achieve running time linear in
- * the number of elements times the inverse Ackermann function.
- */
-class UnionFind final {
-    std::vector<index> parent;
-    std::vector<unsigned char> rank;
-
-public:
-    /**
-     * Create a new set representation with not more than @p max_element elements.
-     * Initially every element is in its own set.
-     * @param max_element maximum number of elements
-     */
-    UnionFind(index max_element) : parent(max_element), rank(max_element, 0) { allToSingletons(); }
-
-    /**
-     * Assigns every element to a singleton set.
-     * Set id is equal to element id.
-     */
-
-    void allToSingletons();
-
-    /**
-     * Find the representative to element @u
-     * @param u element
-     * @return representative of set containing @u
-     */
-    index find(index u);
-
-    /**
-     *  Merge the two sets contain @u and @v
-     *  @param u element u
-     *  @param v element v
-     */
-    void merge(index u, index v);
-
-    /**
-     * Convert the Union Find data structure to a Partition
-     * @return Partition equivalent to the union find data structure
-     * */
-    Partition toPartition();
-};
-} /* namespace NetworKit */
-#endif // NETWORKIT_STRUCTURES_UNION_FIND_HPP_

package/vendor/include/networkit/viz/GraphLayoutAlgorithm.hpp

@@ -1,157 +0,0 @@
-/*
- * GraphLayoutAlgorithm.hpp
- *
- *  Created on: Apr 19, 2016
- *      Author: Michael Wegner
- */
-
-#ifndef NETWORKIT_VIZ_GRAPH_LAYOUT_ALGORITHM_HPP_
-#define NETWORKIT_VIZ_GRAPH_LAYOUT_ALGORITHM_HPP_
-
-#include <fstream>
-#include <vector>
-
-#include <networkit/auxiliary/Enforce.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/viz/Point.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup viz
- * Abstract base class for algorithms that compute a layout of the Graph vertices in d-dimensional
- * space. The coordinates are stored in a d-dimensional @ref Point with type @code T \endcode.
- */
-template <typename T>
-class GraphLayoutAlgorithm {
-public:
-    GraphLayoutAlgorithm(const Graph &G, count dim)
-        : G(&G), vertexCoordinates(std::vector<Point<T>>(G.upperNodeIdBound(), Point<T>(dim))) {}
-    virtual ~GraphLayoutAlgorithm() = default;
-
-    virtual void run() = 0;
-
-    virtual std::vector<Point<T>> getCoordinates() const { return vertexCoordinates; }
-
-    virtual count numEdgeCrossings() const {
-        if (vertexCoordinates[0].getDimensions() == 2) {
-            count numCrossings = 0;
-            G->forEdges([&](node u, node v, edgeweight) {
-                G->forEdges([&](node p, node q, edgeweight) {
-                    if ((p == u && q == v) || (p == v && q == u))
-                        return;
-                    double m1 = (vertexCoordinates[v][1] - vertexCoordinates[u][1])
-                                / (vertexCoordinates[v][0] - vertexCoordinates[u][0]);
-                    double m2 = (vertexCoordinates[q][1] - vertexCoordinates[p][1])
-                                / (vertexCoordinates[q][0] - vertexCoordinates[p][0]);
-
-                    double b1 = vertexCoordinates[u][1] - m1 * vertexCoordinates[u][0];
-                    double b2 = vertexCoordinates[p][1] - m1 * vertexCoordinates[p][0];
-                    if (m1 != m2) {
-                        double xIntersect = (b2 - b1) / (m1 - m2);
-                        double minXE1 = std::min(vertexCoordinates[u][0], vertexCoordinates[v][0]);
-                        double minXE2 = std::min(vertexCoordinates[p][0], vertexCoordinates[q][0]);
-                        double maxXE1 = std::max(vertexCoordinates[u][0], vertexCoordinates[v][0]);
-                        double maxXE2 = std::max(vertexCoordinates[p][0], vertexCoordinates[q][0]);
-
-                        if (minXE1 <= xIntersect && minXE2 <= xIntersect && xIntersect <= maxXE1
-                            && xIntersect <= maxXE2) {
-                            numCrossings++;
-                        }
-                    } else if (b1 == b2) {
-                        numCrossings++;
-                    }
-                });
-            });
-
-            numCrossings /= 2;
-            return numCrossings;
-        }
-
-        return 0;
-    }
-
-    virtual bool writeGraphToGML(std::string_view filePath) {
-        if (vertexCoordinates.empty() || vertexCoordinates[0].getDimensions() < 2
-            || vertexCoordinates[0].getDimensions() > 3)
-            return false;
-        count dim = vertexCoordinates[0].getDimensions();
-        std::ofstream file(filePath.data());
-        Aux::enforceOpened(file);
-
-        file << "graph [\n";
-        if (G->isDirected()) {
-            file << "  directed 1\n";
-        }
-
-        G->forNodes([&](node u) {
-            file << "  node [\n";
-            file << "    id " << u << "\n";
-            file << "    graphics\n";
-            file << "    [ x " << 50 * vertexCoordinates[u][0] << "\n";
-            file << "      y " << 50 * vertexCoordinates[u][1] << "\n";
-            if (dim == 3) {
-                file << "      z " << 50 * vertexCoordinates[u][2] << "\n";
-            }
-            file << "    ]\n";
-            file << "  ]\n";
-        });
-
-        G->forEdges([&](node u, node v) {
-            file << "  edge [\n";
-            file << "    source " << u << "\n";
-            file << "    target " << v << "\n";
-            file << "  ]\n";
-        });
-        file << "]\n";
-
-        file.close();
-
-        return true;
-    }
-
-    virtual bool writeKinemage(std::string_view filePath) {
-        if (vertexCoordinates.empty() || vertexCoordinates[0].getDimensions() != 3)
-            return false;
-        std::string_view fileName = filePath.substr(filePath.find_last_of("/"));
-        std::ofstream file(filePath.data());
-        Aux::enforceOpened(file);
-
-        file << "@whitebackground" << std::endl;
-        file << "@zoom 1.0" << std::endl;
-        file << "@zslab 240" << std::endl;
-        file << "@center 0 0 0" << std::endl;
-        file << "@master{points}" << std::endl;
-        file << "@group{" << fileName << "}" << std::endl;
-        file << "@balllist {a} color= blue master={points} radius= 0.05" << std::endl;
-
-        G->forNodes([&](node u) {
-            file << "{a}" << vertexCoordinates[u][0] << " " << vertexCoordinates[u][1] << " "
-                 << vertexCoordinates[u][2] << std::endl;
-        });
-
-        // edges
-        file << std::endl;
-        file << "@subgroup {edges} dominant" << std::endl;
-        file << "@vectorlist {edges} color= white" << std::endl;
-        G->forEdges([&](node u, node v) {
-            file << "P " << vertexCoordinates[u][0] << " " << vertexCoordinates[u][1] << " "
-                 << vertexCoordinates[u][2] << std::endl;
-            file << vertexCoordinates[v][0] << " " << vertexCoordinates[v][1] << " "
-                 << vertexCoordinates[v][2] << std::endl;
-        });
-
-        file << std::endl;
-
-        file.close();
-        return true;
-    }
-
-protected:
-    const Graph *G;
-    std::vector<Point<T>> vertexCoordinates;
-};
-
-} /* namespace NetworKit */
-
-#endif // NETWORKIT_VIZ_GRAPH_LAYOUT_ALGORITHM_HPP_

package/vendor/include/networkit/viz/MaxentStress.hpp

@@ -1,346 +0,0 @@
-/*
- * MaxentStress.hpp
- *
- *  Created on: 22.01.2014
- *      Author: Henning Meyerhenke and Michael Wegner
- */
-
-#ifndef NETWORKIT_VIZ_MAXENT_STRESS_HPP_
-#define NETWORKIT_VIZ_MAXENT_STRESS_HPP_
-
-#include <memory>
-
-#include <networkit/algebraic/CSRMatrix.hpp>
-#include <networkit/auxiliary/StringTools.hpp>
-#include <networkit/distance/AlgebraicDistance.hpp>
-#include <networkit/numerics/LinearSolver.hpp>
-#include <networkit/viz/GraphLayoutAlgorithm.hpp>
-#include <networkit/viz/Octree.hpp>
-
-namespace NetworKit {
-
-using CoordinateVector =
-    std::vector<Vector>; // more meaningful and shorter name for coordinates stored by dimension
-
-struct ForwardEdge {
-    node head;
-    edgeweight weight;
-};
-
-/**
- * @ingroup viz
- *
- * Implementation of MaxentStress by Ganser et al. using a laplacian system solver.
- *
- * @see Ganser, Emden R., Yifan Hu and Steve North. "A maxentstress model for graph layout."
- * Visualisation and Computer Graphics, IEEE Transsactions on 19, no. 6 (2013): 927-940.
- */
-
-class MaxentStress final : public GraphLayoutAlgorithm<double> {
-public:
-    enum GraphDistance { EDGE_WEIGHT, ALGEBRAIC_DISTANCE };
-
-    enum LinearSolverType {
-        LAMG,
-        CONJUGATE_GRADIENT_IDENTITY_PRECONDITIONER,
-        CONJUGATE_GRADIENT_DIAGONAL_PRECONDITIONER
-    };
-
-    struct ResultStats {
-        double rhsTime = 0.0;
-        double approxEntropyTerm = 0.0;
-        double solveTime = 0.0;
-    };
-
-    MaxentStress(const Graph &G, count dim, count k, double tolerance,
-                 LinearSolverType linearSolverType = LAMG, bool fastComputation = false,
-                 GraphDistance graphDistance = EDGE_WEIGHT);
-
-    MaxentStress(const Graph &G, count dim, const std::vector<Point<double>> &coordinates, count k,
-                 double tolerance, LinearSolverType linearSolverType = LAMG,
-                 bool fastComputation = false, GraphDistance graphDistance = EDGE_WEIGHT);
-
-    /** Default destructor. */
-    ~MaxentStress() override = default;
-
-    /** Computes a graph drawing according to the Maxent-Stress model. */
-    void run() override;
-
-    /**
-     * Scale the layout computed by @ref run() by a scalar s to minimize \sum_{u,v \in V} w_{uv} (s
-     * ||x_u - x_v|| - d_{uv}||)^2
-     */
-    void scaleLayout();
-
-    /**
-     * Computes a scalar s s.t. \sum_{u,v \in V} w_{uv} (s ||x_u - x_v|| - d_{uv}||)^2 is minimized.
-     */
-    double computeScalingFactor();
-
-    /**
-     * Computes the full stress measure of the computed layout with @ref run(). Code taken and
-     * adapted from KaDraw by Christian Schulz.
-     * @note KaDraw: http://algo2.iti.kit.edu/kadraw/
-     */
-    double fullStressMeasure();
-
-    /**
-     * Computes the maxent stress measure for the computed layout with @a run(). Code taken and
-     * adapted from KaDraw by Christian Schulz.
-     * @note KaDraw: http://algo2.iti.kit.edu/kadraw/
-     */
-    double maxentMeasure();
-
-    double meanDistanceError();
-
-    double ldme();
-
-    /**
-     * Set parameter @a q.
-     * @param q
-     */
-    void setQ(double q) { this->q = q; }
-
-    /**
-     * Set parameter @a alpha.
-     * @param alpha
-     */
-    void setAlpha(double alpha) { this->alpha = alpha; }
-
-    /**
-     * Set parameter @a alphaReduction.
-     * @param alphaReduction
-     */
-    void setAlphaReduction(double alphaReduction) { this->alphaReduction = alphaReduction; }
-
-    /**
-     * Set parameter @a finalAlpha.
-     * @param finalAlpha
-     */
-    void setFinalAlpha(double finalAlpha) { this->finalAlpha = finalAlpha; }
-
-    void setConvergenceThreshold(double convThreshold) {
-        this->convThreshold = convThreshold * convThreshold;
-    }
-
-    double getRhs() { return this->resultStats.rhsTime; };
-
-    double getApproxEntropyTerm() { return this->resultStats.approxEntropyTerm; };
-
-    double getSolveTime() { return this->resultStats.solveTime; };
-
-private:
-    /**
-     * Calls run() and returns the corresponding stats.
-     */
-
-    ResultStats runAlgo();
-
-    /**
-     * Reference to the linear solver to use during the maxent-stress algorithm.
-     */
-    LinearSolver<CSRMatrix> &solver;
-
-    /**
-     * Stats of the last time run() was called.
-     */
-
-    ResultStats resultStats;
-
-    /** Parameters of the MaxentStress model **/
-    double q, alpha, alphaReduction, finalAlpha, convThreshold;
-
-    /** Specifies whether initial coordinates have been provided in the constructor */
-    bool coordinatesProvided;
-
-    /** Defines whether the algorithm stops when converged on a higher than the lowest level. This
-     * saves some time but usually leads to slightly worse results.
-     */
-    bool fastComputation;
-
-    /** Maximum number of solves for the same value of alpha **/
-    count maxSolvesPerAlpha;
-
-    /** set known distances (S in the paper of Gansner et al.) */
-    std::vector<std::vector<ForwardEdge>> knownDistances;
-
-    /** cardinality of S */
-    count knownDistancesCardinality;
-
-    /** points of vertices are in R^{dim} */
-    count dim;
-
-    /**
-     * Determines whether the run() method has already been called.
-     */
-    bool hasRun;
-
-    /**
-     * Checks whether the MaxentStress algorithm converged, i.e. ||newCoords - oldCoords|| /
-     * ||oldCoords|| < convThreshold.
-     * @param newCoords The new coordinates computed in the current round of the algorithm.
-     * @param oldCoords The coordinates from the previous round of the algorithm.
-     * @return @code True when converged, otherwise \endcode false.
-     */
-    bool isConverged(const CoordinateVector &newCoords, const CoordinateVector &oldCoords);
-
-    /**
-     * Create a weighted Laplacian matrix from G and setup the solver for this matrix.
-     */
-    void setupWeightedLaplacianMatrix();
-
-    /**
-     * Computes the vector L_{w,d}*x where x is stored in @a coordinates and stores the result in @a
-     * rhs.
-     * @param coordinates The coordinate vector (x in the thesis)
-     * @param rhs The right-hand side that stores the result of the matrix-vector multiplication.
-     */
-    void computeCoordinateLaplacianTerm(const CoordinateVector &coordinates, CoordinateVector &rhs);
-
-    /**
-     * Computes the repulsive forces according to Equation (8) in Gansner et al.
-     * @param coordinates The current coordinates of the vertices.
-     * @param b Repulsive force vector to compute
-     */
-    CoordinateVector computeRepulsiveForces(const CoordinateVector &coordinates,
-                                            CoordinateVector &b) const;
-
-    /**
-     * Approximates the repulsive forcse by means of an octree (Barnes and Hut).
-     * @param coordinates The current coordinates of the vertices.
-     * @param octree Octree for Barnes-Hut approximation
-     * @param theta Parameter for Barnes-Hut cell-opening criterion
-     * @param b Repulsive force vector to compute
-     */
-    void approxRepulsiveForces(const CoordinateVector &coordinates, const Octree<double> &octree,
-                               double theta, CoordinateVector &b) const;
-
-    /**
-     * Initializes the @a coordinates corresponding to vertices in the Graph to a random point in
-     * d-dimensional space 2000^d pixel.
-     * @param coordinates The coordinates of the graph.
-     */
-    void randomInitCoordinates(CoordinateVector &coordinates) const;
-
-    /**
-     * Initialized the @a coordinates corresponding to vertices in the Graph acoording to the random
-     * sphere placement algorithm.
-     * @param coordinates The coordinates of the graph vertices.
-     */
-    void randomSphereCoordinates(CoordinateVector &coordinates) const;
-
-    /**
-     * Computes the squared distance ||c_i - c_j||^2 between @a coordinates @a i and @a j
-     * @param coordinates
-     * @param i
-     * @param j
-     */
-    double squaredDistance(const CoordinateVector &coordinates, index i, index j) const;
-
-    /**
-     * Computes the distance ||c_i - c_j|| between @a coordinates @a i and @a j.
-     * @param coordinates
-     * @param i
-     * @param j
-     */
-    inline double distance(const CoordinateVector &coordinates, const index i,
-                           const index j) const {
-        return std::sqrt(squaredDistance(coordinates, i, j));
-    }
-
-    /**
-     * Computes the squared distance ||c1_i - c2_j||^2 between coordinate @a i from @a coordinates1
-     * and coordinate @a j from @a coordinates 2.
-     * @param coordinates1
-     * @param coordinates2
-     * @param i
-     * @param j
-     */
-    double squaredDistance(const CoordinateVector &coordinates1,
-                           const CoordinateVector &coordinates2, index i, index j) const;
-
-    /**
-     * Computes the squared distance ||c1_i - c2_j|| between coordinate @a i from @a coordinates1
-     * and coordinate @a j from @a coordinates 2.
-     * @param coordinates1
-     * @param coordinates2
-     * @param i
-     * @param j
-     */
-    inline double distance(const CoordinateVector &coordinates1,
-                           const CoordinateVector &coordinates2, const index i,
-                           const index j) const {
-        return std::sqrt(squaredDistance(coordinates1, coordinates2, i, j));
-    }
-
-    /**
-     * Computes the squared length ||c_i||^2 of coordinate @a i in @a coordinates.
-     * @param coordinates
-     * @param i
-     */
-    double squaredLength(const CoordinateVector &coordinates, index i) const;
-
-    /**
-     * Computes the length ||c_i|| of coordinate @a i in @a coordinates.
-     * @param coordinates
-     * @param i
-     */
-    inline double length(const CoordinateVector &coordinates, const index i) const {
-        return std::sqrt(squaredLength(coordinates, i));
-    }
-
-    /**
-     * Weighting factor, Gansner et al. propose 1/(edgeWeight^2).
-     * @param edgeWeight The graph-theoretic distance between two vertices (i.e. the edge weight).
-     * @return The corresponding weighting factor.
-     */
-    inline double weightingFactor(double edgeWeight) const {
-        return 1.0 / (edgeWeight * edgeWeight);
-    }
-
-    /**
-     * Returns the sign of @a value. The sign of 0.0 is defined to be positive.
-     * @param value
-     */
-    inline double sign(const double value) const { return (value >= 0.0) - (value < 0.0); }
-
-    /**
-     * Returns the point at index @a i stored in @a coordinates.
-     * @param coordinates
-     * @param i
-     */
-    inline Point<double> getPoint(const CoordinateVector &coordinates, index i) const {
-        Point<double> p(coordinates.size());
-        for (index d = 0; d < p.getDimensions(); ++d) {
-            assert(coordinates[d].getDimension() > i);
-            p[d] = coordinates[d][i];
-        }
-
-        return p;
-    }
-
-    /**
-     * Computes the distances from each vertex to its k-hop neighborhood according to the @a
-     * graphDistance type (edge weights or algebraic distance).
-     * @param k
-     * @param graphDistance
-     */
-    void computeKnownDistances(count k, GraphDistance graphDistance);
-
-    /**
-     * Add the k-neighborhood (except for the 1-neighbors) of vertex @a u to the knownDistances of
-     * @a u
-     * @param u
-     */
-    void addKNeighborhoodOfVertex(node u, count k);
-
-    /**
-     * Computes the algebraic distances from each vertex to its k-hop neighborhood.
-     * @param graph
-     * @param k
-     */
-    void computeAlgebraicDistances(const Graph &graph, count k);
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_VIZ_MAXENT_STRESS_HPP_