@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/io/METISParser.hpp

@@ -0,0 +1,63 @@
+/*
+ * METISParser.hpp
+ *
+ *  Created on: 27.11.2012
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_METIS_PARSER_HPP_
+#define NETWORKIT_IO_METIS_PARSER_HPP_
+
+#include <fstream>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Parser for the METIS file format.
+ */
+class METISParser final {
+
+    std::ifstream graphFile;
+
+public:
+    /**
+     * Constructor for the METIS Parser.
+     *
+     * @param[in]  path  file path
+     */
+    METISParser(std::string_view path);
+
+    /**
+     * Get the METIS graph file header
+     */
+    std::tuple<count, count, index, count> getHeader();
+
+    /**
+     * Test if graph file has a next line.
+     */
+    bool hasNext();
+
+    /**
+     * Get adjacencies from the next line in the METIS graph file.
+     *
+     * @param[in]  ignoreFirst  number of values to ignore [in case the METIS file contains node
+     * weightes]
+     */
+    std::vector<node> getNext(count ignoreFirst = 0);
+
+    /**
+     * Get adjacencies with edge weights from the next line in the METIS graph file.
+     *
+     * @param[in]  ignoreFirst  number of values to ignore [in case the METIS file contains node
+     * weightes]
+     */
+    std::vector<std::pair<node, double>> getNextWithWeights(count ignoreFirst = 0);
+};
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_METIS_PARSER_HPP_

package/vendor/include/networkit/io/MTXGraphReader.hpp

@@ -0,0 +1,31 @@
+#ifndef NETWORKIT_IO_MTX_GRAPH_READER_HPP_
+#define NETWORKIT_IO_MTX_GRAPH_READER_HPP_
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ *
+ * Reader for the matrix market file format documented in
+ * https://networkrepository.com/mtx-matrix-market-format.html
+ *
+ * Does not allow complex fields.
+ *
+ */
+class MTXGraphReader final : public GraphReader {
+public:
+    MTXGraphReader() = default;
+
+    /**
+     * Takes a file path as parameter and returns a graph.
+     *
+     * @param path
+     * @return Graph
+     */
+    GraphW read(std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_MTX_GRAPH_READER_HPP_

package/vendor/include/networkit/io/MTXParser.hpp

@@ -0,0 +1,87 @@
+#ifndef NETWORKIT_IO_MTX_PARSER_HPP_
+#define NETWORKIT_IO_MTX_PARSER_HPP_
+
+#include <fstream>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <vector>
+
+#include <networkit/Globals.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+/**
+ * @ingroup io
+ * Parser for the MTX file format.
+ */
+class MTXParser final {
+
+    std::ifstream graphFile;
+    std::string currentLine;
+
+public:
+    enum class Object { Matrix, Vector };
+    enum class Format { Coordinate, Array };
+    enum class Field { Real, Double, Complex, Integer, Pattern };
+    enum class Symmetry { General, Symmetric, SkewSymmetric, Hermitian };
+
+    std::unordered_map<std::string, Object> objectMap = {{"matrix", Object::Matrix},
+                                                         {"vector", Object::Vector}};
+    std::unordered_map<std::string, Format> formatMap = {{"coordinate", Format::Coordinate},
+                                                         {"array", Format::Array}};
+    std::unordered_map<std::string, Field> fieldMap = {{"real", Field::Real},
+                                                       {"double", Field::Double},
+                                                       {"integer", Field::Integer},
+                                                       {"pattern", Field::Pattern}};
+    std::unordered_map<std::string, Symmetry> symmetryMap = {
+        {"general", Symmetry::General},
+        {"symmetric", Symmetry::Symmetric},
+        {"skew-symmetric", Symmetry::SkewSymmetric}};
+
+    struct MTXHeader {
+        Object object;
+        Format format;
+        Field field;
+        Symmetry symmetry;
+    };
+
+    struct MatrixSize {
+        count rows;
+        count columns;
+        count nonzeros;
+
+        MatrixSize(count r, count c, count nz) : rows(r), columns(c), nonzeros(nz) {}
+    };
+
+    struct Edge {
+        node from;
+        node to;
+        std::optional<double> weight;
+
+        Edge(node f, node t, std::optional<double> w) : from(f), to(t), weight(w) {}
+    };
+
+    MTXParser(const std::string &path);
+
+    /**
+     * Get the MTX graph file header.
+     */
+    MTXHeader getHeader();
+
+    /**
+     * Get the MTX graph file matrix size header.
+     */
+    MatrixSize getMatrixSize();
+
+    /**
+     * Get the (weighted) edge from the next line in the MTX graph file if present.
+     *
+     * @param weighted
+     * @return std::optional<std::pair<NetworKit::Edge, NetworKit::edgeweight>>
+     */
+    std::optional<NetworKit::WeightedEdge> getNext(bool weighted);
+};
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_MTX_PARSER_HPP_

package/vendor/include/networkit/io/MatrixMarketReader.hpp

@@ -0,0 +1,33 @@
+/*
+ * MatrixMarketReader.hpp
+ *
+ *  Created on: 25.07.2014
+ *      Author: dhoske
+ */
+
+#ifndef NETWORKIT_IO_MATRIX_MARKET_READER_HPP_
+#define NETWORKIT_IO_MATRIX_MARKET_READER_HPP_
+
+#include <networkit/io/MatrixReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Reader for the matrix market file format as described in
+ * http://math.nist.gov/MatrixMarket/reports/MMformat.ps.
+ *
+ * Only allows real, symmetric matrices.
+ */
+class MatrixMarketReader final : public MatrixReader {
+public:
+    MatrixMarketReader() = default;
+
+    CSRMatrix read(std::string_view path) override;
+
+    /** Reads the matrix in @a in. */
+    CSRMatrix read(std::istream &in);
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_IO_MATRIX_MARKET_READER_HPP_

package/vendor/include/networkit/io/MatrixReader.hpp

@@ -0,0 +1,33 @@
+/*
+ * MatrixReader.hpp
+ *
+ *  Created on: 17.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_MATRIX_READER_HPP_
+#define NETWORKIT_IO_MATRIX_READER_HPP_
+
+#include <networkit/algebraic/CSRMatrix.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Abstract base class for matrix readers.
+ */
+class MatrixReader {
+public:
+    virtual ~MatrixReader() = default;
+
+    /**
+     * Reads the matrix in @a path.
+     */
+    virtual CSRMatrix read(std::string_view path) = 0;
+
+    /** only to be used by Cython - this eliminates an unnecessary copy */
+    CSRMatrix *_read(std::string_view path) { return new CSRMatrix{read(path)}; };
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_IO_MATRIX_READER_HPP_

package/vendor/include/networkit/io/MemoryMappedFile.hpp

@@ -0,0 +1,80 @@
+/*
+ * MemoryMappedFile.hpp
+ *
+ *  Created on: 16.07.2018
+ *      Author: Manuel Penschuck (networkit@manuel.jetzt)
+ */
+
+#ifndef NETWORKIT_IO_MEMORY_MAPPED_FILE_HPP_
+#define NETWORKIT_IO_MEMORY_MAPPED_FILE_HPP_
+
+#include <memory>
+#include <string>
+
+namespace NetworKit {
+struct MemoryMappedFileState;
+
+/**
+ * This class is a wrapper to os-dependend file mapping implementations.
+ * It supports to map a read-only file into virtual address space.
+ * After successful opening, pointers to the begin/end of the virtual
+ * address space are accessible via cbegin() / cend(). All file and mapping
+ * handlers are freed automatically.
+ *
+ * This wrapper is non-copyable but can be cheaply moved and swapped.
+ */
+class MemoryMappedFile final {
+public:
+    using value_type = char;
+    using const_iterator = const value_type *;
+
+    //! Creates a MemoryMappedFile instance in an unmapped state.
+    //! A call to open() is required.
+    MemoryMappedFile();
+
+    //! Invokes open(path) automatically
+    explicit MemoryMappedFile(std::string_view path);
+
+    //! Invokes close
+    ~MemoryMappedFile();
+
+    //! It's non copy-able
+    MemoryMappedFile(const MemoryMappedFile &) = delete;
+    MemoryMappedFile &operator=(const MemoryMappedFile &) = delete;
+
+    //! Takes over the mapping (if any) from o, leaves o in a "closed"
+    //! state ready to be opened again.
+    MemoryMappedFile(MemoryMappedFile &&o) noexcept;
+
+    //! If *this currently holds a mapping, it is closed and replaced
+    //! the other's state which in turn is left closed.
+    MemoryMappedFile &operator=(MemoryMappedFile &&o) noexcept;
+
+    //! Opens the file and maps it to cbegin() ... cend()
+    //! Opening an empty file is considered an error.
+    void open(std::string_view file);
+
+    //! If a file is mapped, it is closed. Otherwise, operation is carried out.
+    //! @note This function is automatically called by the destructor.
+    void close() noexcept;
+
+    //! If a file is opened, a random-access iterator to the first byte mapped is returned.
+    //! If no file is opened, nullptr is returned.
+    const_iterator cbegin() const { return beginIt; }
+
+    //! Analogously to cbegin()
+    const_iterator cend() const { return endIt; }
+
+    //! Number of bytes mapped
+    size_t size() const { return std::distance(beginIt, endIt); }
+
+private:
+    const_iterator beginIt{nullptr};
+    const_iterator endIt{nullptr};
+
+    //!< used only by Windows implementation to keep handlers around.
+    std::unique_ptr<MemoryMappedFileState> state;
+};
+
+} // namespace NetworKit
+#endif // NETWORKIT_IO_MEMORY_MAPPED_FILE_HPP_

package/vendor/include/networkit/io/NetworkitBinaryGraph.hpp

@@ -0,0 +1,144 @@
+/*
+ * NetworkitBinaryGraph.hpp
+ *
+ *      Author: Charmaine Ndolo <charmaine.ndolo@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_IO_NETWORKIT_BINARY_GRAPH_HPP_
+#define NETWORKIT_IO_NETWORKIT_BINARY_GRAPH_HPP_
+
+#include <cstddef>
+#include <cstdint>
+
+#include <tlx/define/likely.hpp>
+#include <tlx/math/clz.hpp>
+#include <tlx/math/ffs.hpp>
+
+namespace NetworKit {
+namespace nkbg {
+
+struct Header {
+    char magic[8];
+    uint64_t checksum;
+    uint64_t features;
+    uint64_t nodes;
+    uint64_t chunks;
+    uint64_t offsetBaseData;
+    uint64_t offsetAdjLists;
+    uint64_t offsetAdjTranspose;
+    uint64_t offsetWeightLists;
+    uint64_t offsetWeightTranspose;
+    uint64_t offsetAdjIdLists;
+    uint64_t offsetAdjIdTranspose;
+};
+
+enum class WeightFormat : int { NONE = 0, VARINT = 1, SIGNED_VARINT = 2, DOUBLE = 3, FLOAT = 4 };
+
+using WEIGHT_FORMAT = WeightFormat; // enum alias for backwards compatibility
+
+static constexpr uint8_t DELETED_BIT = 0x1; // bit 0
+static constexpr uint64_t DIR_MASK = 0x1;   // bit 0
+static constexpr uint64_t WGHT_MASK = 0xE;  // bit 1-3
+static constexpr uint64_t WGHT_SHIFT = 0x1;
+static constexpr uint64_t INDEX_MASK = 0x10; // bit 4
+static constexpr uint64_t INDEX_SHIFT = 0x4;
+
+/**
+ * Serializes value into a buffer and returns the number of bytes written.
+ * The space required to store an integer x ranges between 1 and 9 bytes.
+ *
+ * The first byte (buffer[0]) encodes the number of following data bytes
+ * in the position y in [0, 7] of the least significant bit that is asserted.
+ * If the header byte is zero (i.e., it contains no asserted bits), exactly
+ * y=8 data bytes follow.
+ * Possibly remaining bits in the header are used to store the least
+ * significant bits of x. The subsequent data bytes store the remainder of x
+ * in little endian, i.e. * the eight least significant bits (not stored in
+ * the header) are stored in buffer[1], the next higher eight bits in
+ * buffer[2] and so on.
+ *
+ * Example:
+ * x = 0b0GFE'DCBA with G=1 requires 7 bits of storage. Hence it fits
+ * completely into the header which is
+ * buffer[0] = 0bGFED'CBA|1 where bit 0 encodes that no
+ * data bytes follow while bits 1 to 7 store x.
+ *
+ * x = 0bHGFE'DCBA with H=1 requires 8 bits of storage. Hence an
+ * additional data byte is required:
+ *
+ * buffer[0] = 0bFEDC'BA|10 where bits 0 and 1 encode that one data byte will follow
+ * buffer[1] = 0b0000'00|HG where bits 0 and 1 encode the remaining two bits
+ * of x, and bits 2 to 7 are filled as zeros
+ */
+
+inline size_t varIntEncode(uint64_t value, uint8_t *buffer) noexcept {
+    if (!value) {
+        buffer[0] = 1;
+        return 1;
+    }
+
+    int dataBytes;
+
+    if (TLX_UNLIKELY(value >= (1llu << 56))) {
+        // We have more than 56 bits of data, i.e. we need 8 data bytes.
+        buffer[0] = 0;
+        dataBytes = 8;
+
+    } else {
+        const auto bits = 64 - tlx::clz(value);
+        dataBytes = static_cast<int>((bits - 1) / 7);
+
+        // number of bytes is encode by the number of trailing zeros
+        buffer[0] = static_cast<uint8_t>(1 << dataBytes);
+
+        // put the 8 - (dataBytes - 1) least significant bits into the remainder of the buffer byte
+        buffer[0] |= static_cast<uint8_t>(value << (dataBytes + 1));
+        value >>= 7 - dataBytes;
+    }
+
+    for (int i = 0; i < dataBytes; i++) {
+        buffer[i + 1] = static_cast<uint8_t>(value & 0xFF);
+        value >>= 8;
+    }
+
+    return dataBytes + 1;
+}
+
+/// Converts a serialized varint into an uint64_t value and returns the number of bytes consumed.
+inline size_t varIntDecode(const uint8_t *data, uint64_t &value) noexcept {
+    int n = 8;
+    int bitsRecovered = 0;
+    uint64_t decoded = 0;
+
+    if (data[0]) {
+        n = static_cast<int>(tlx::ffs(data[0]) - 1);
+        decoded = data[0] >> (n + 1);
+        bitsRecovered = 7 - n;
+    }
+
+    for (int i = 0; i < n; i++) {
+        decoded |= static_cast<uint64_t>(data[i + 1]) << bitsRecovered;
+        bitsRecovered += 8;
+    }
+
+    value = decoded;
+    return n + 1;
+}
+
+/**
+ * Encodes a singed value, s.t. the sign bit is in the LSB bit, while the absolute value is
+ * stored in the remaining upper 63 bits. This allows more effective compression using varint.
+ */
+inline uint64_t zigzagEncode(int64_t value) noexcept {
+    return (static_cast<uint64_t>(value) << 1) ^ (int64_t(-1) * (value < 0));
+}
+
+//! Reverses zigzagEncode.
+inline int64_t zigzagDecode(uint64_t value) noexcept {
+    return (value >> 1) ^ (-(value & 1));
+}
+
+} // namespace nkbg
+} // namespace NetworKit
+
+#endif // NETWORKIT_IO_NETWORKIT_BINARY_GRAPH_HPP_

package/vendor/include/networkit/io/NetworkitBinaryReader.hpp

@@ -0,0 +1,50 @@
+/*
+ * NetworkitBinaryReader.hpp
+ *
+ *      Author: Charmaine Ndolo <charmaine.ndolo@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_IO_NETWORKIT_BINARY_READER_HPP_
+#define NETWORKIT_IO_NETWORKIT_BINARY_READER_HPP_
+
+#include <cstring>
+#include <string>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/io/GraphReader.hpp>
+#include <networkit/io/MemoryMappedFile.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ *
+ * Reads a graph written in the custom Networkit binary format.
+ * Note that there are multiple versions of the Networkit binary format.
+ * This Reader can read files that are written with format version 2 and 3.
+ * Format version 3 was released with Networkit 9.1 (December 2021).
+ * Further information can be found here:
+ * https://github.com/networkit/networkit/blob/master/networkit/cpp/io/NetworkitBinaryGraph.md
+ */
+
+class NetworkitBinaryReader final : public GraphReader {
+
+public:
+    NetworkitBinaryReader(){};
+
+    GraphW read(std::string_view path) override;
+    GraphW readFromBuffer(const std::vector<uint8_t> &data);
+
+private:
+    count nodes;
+    count chunks;
+    bool directed;
+    bool weighted;
+    bool indexed;
+    count version;
+
+    template <class T>
+    GraphW readData(const T &source);
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_IO_NETWORKIT_BINARY_READER_HPP_

package/vendor/include/networkit/io/NetworkitBinaryWriter.hpp

@@ -0,0 +1,71 @@
+/*
+ * NetworkitBinaryWriter.hpp
+ *
+ *      Author: Charmaine Ndolo <charmaine.ndolo@hu-berlin.de>
+ */
+
+#ifndef NETWORKIT_IO_NETWORKIT_BINARY_WRITER_HPP_
+#define NETWORKIT_IO_NETWORKIT_BINARY_WRITER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+enum class NetworkitBinaryWeights : int {
+    NONE,
+    UNSIGNED_FORMAT,
+    SIGNED_FORMAT,
+    DOUBLE_FORMAT,
+    FLOAT_FORMAT,
+    AUTO_DETECT,
+    none = NONE, // this + following added for backwards compatibility
+    unsignedFormat = UNSIGNED_FORMAT,
+    signedFormat = SIGNED_FORMAT,
+    doubleFormat = DOUBLE_FORMAT,
+    floatFormat = FLOAT_FORMAT,
+    autoDetect = AUTO_DETECT
+};
+
+enum class NetworkitBinaryEdgeIDs : int {
+    NO_EDGE_IDS,
+    WIRTE_EDGE_IDS,
+    AUTO_DETECT,
+    noEdgeIDs = NO_EDGE_IDS, // this + following added for backwards compatibility
+    writeEdgeIDs = WIRTE_EDGE_IDS,
+    autoDetect = AUTO_DETECT
+};
+
+/**
+ * @ingroup io
+ *
+ * Writes a graph written in the custom Networkit format.
+ * Note that there are multiple versions of the Networkit binary format.
+ * Since Networkit 9.1 (December 2021), the writer always writes files using format version 3.
+ * Reading a binary file with version < 3 and re-writing it, implicitly upgrades the format to the
+ * current version. Further information can be found here:
+ * https://github.com/networkit/networkit/blob/master/networkit/cpp/io/NetworkitBinaryGraph.md
+ */
+class NetworkitBinaryWriter final : public GraphWriter {
+
+public:
+    NetworkitBinaryWriter(uint64_t chunks = 32,
+                          NetworkitBinaryWeights weightsType = NetworkitBinaryWeights::AUTO_DETECT,
+                          NetworkitBinaryEdgeIDs edgeIndex = NetworkitBinaryEdgeIDs::AUTO_DETECT);
+
+    void write(const Graph &G, std::string_view path) override;
+    std::vector<uint8_t> writeToBuffer(const Graph &G);
+
+private:
+    count chunks;
+    NetworkitBinaryWeights weightsType;
+    NetworkitBinaryEdgeIDs edgeIndex;
+    bool preserveEdgeIndex;
+
+    template <class T>
+    void writeData(T &outStream, const Graph &G);
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_IO_NETWORKIT_BINARY_WRITER_HPP_

package/vendor/include/networkit/io/PartitionReader.hpp

@@ -0,0 +1,34 @@
+/*
+ * PartitionReader.hpp
+ *
+ *  Created on: 15.02.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_PARTITION_READER_HPP_
+#define NETWORKIT_IO_PARTITION_READER_HPP_
+
+#include <fstream>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class PartitionReader final {
+
+public:
+    /**
+     * Read a clustering from a file. File format:
+     *     line n contains cluster id of node (n - 1)
+     *
+     * @param[in]  path  Path to file.
+     */
+    Partition read(std::string_view path);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_PARTITION_READER_HPP_

package/vendor/include/networkit/io/PartitionWriter.hpp

@@ -0,0 +1,31 @@
+/*
+ * PartitionWriter.hpp
+ *
+ *  Created on: 22.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_PARTITION_WRITER_HPP_
+#define NETWORKIT_IO_PARTITION_WRITER_HPP_
+
+#include <fstream>
+
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Write a clustering to a file.
+ */
+class PartitionWriter final {
+
+public:
+    void write(const Partition &zeta, std::string_view path) const {
+        std::ofstream file{path.data()};
+        zeta.forEntries([&](node, const index c) { file << c << '\n'; });
+    }
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_PARTITION_WRITER_HPP_

package/vendor/include/networkit/io/RBGraphReader.hpp

@@ -0,0 +1,37 @@
+/*
+ * RBGraphReader.hpp
+ *
+ *  Created on: 16.10.2024
+ *      Author: bernlu
+ */
+
+#ifndef NETWORKIT_IO_RB_GRAPH_READER_HPP_
+#define NETWORKIT_IO_RB_GRAPH_READER_HPP_
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Reader for the Rutherford Boeing (RB) matrix file format as described in
+ * http://sparse-files.engr.tamu.edu/files/DOC/rb.pdf.
+ *
+ * @note currently the reader only supports compressed column format for real, integer, or pattern
+ * data types.
+ */
+class RBGraphReader final : public GraphReader {
+public:
+    RBGraphReader() = default;
+
+    /**
+     * Takes a file path as parameter and returns a graph.
+     *
+     * @param path
+     * @return Graph
+     */
+    GraphW read(std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_RB_GRAPH_READER_HPP_