@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/networkit/community/ClusteringGenerator.hpp

@@ -1,75 +0,0 @@
-/*
- * ClusteringGenerator.hpp
- *
- *  Created on: 10.12.2012
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_COMMUNITY_CLUSTERING_GENERATOR_HPP_
-#define NETWORKIT_COMMUNITY_CLUSTERING_GENERATOR_HPP_
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Provides several methods for generating special clusterings.
- */
-class ClusteringGenerator final {
-
-public:
-    /**
-     * Make a singleton clustering of Graph @a G, i.e. a clustering in which every node
-     * belongs to its own cluster.
-     *
-     * @param G The graph.
-     * @return A Partition in which every node belongs to its own cluster.
-     */
-    Partition makeSingletonClustering(const Graph &G);
-
-    /**
-     * Make a 1-clustering of Graph @a G, i.e. a clustering in which all nodes belong to the same
-     * cluster.
-     *
-     * @param G The graph.
-     * @return A Partition in which all nodes belong to the same cluster.
-     */
-    Partition makeOneClustering(const Graph &G);
-
-    /**
-     * Make a clustering of Graph @a G with @a k clusters to which the nodes are randomly assigned.
-     *
-     * @param G The graph.
-     * @param k The amount of clusters.
-     * @return A Partition with @a k clusters and each node randomly assigned to one of them.
-     */
-    Partition makeRandomClustering(const Graph &G, count k);
-
-    /**
-     * Make a clustering of Graph @a G with @a k clusters. The first n/k nodes are assigned to the
-     * first cluster, the next n/k nodes to the second cluster and so on.
-     *
-     * @param G The graph.
-     * @param k The amount of clusters.
-     * @return A Partition with @a k clusters and each node assigned like described above.
-     */
-    Partition makeContinuousBalancedClustering(const Graph &G, count k);
-
-    /**
-     * Make a clustering of a Graph @a G with @a k clusters. Each node u is assigned to cluster u %
-     * k. When the number of nodes n is quadratic and k is the square root of n, this clustering is
-     * complementary to the continuous balanced clustering in the sense that no pair of nodes that
-     * is in the same cluster in one of the clusterings is in the same cluster in the other
-     * clustering.
-     *
-     * @param G The graph.
-     * @param k The amount of clusters.
-     * @return A Partition with @a k clusters and each node assigned as described above.
-     */
-    Partition makeNoncontinuousBalancedClustering(const Graph &G, count k);
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_CLUSTERING_GENERATOR_HPP_

package/vendor/include/networkit/community/CommunityDetectionAlgorithm.hpp

@@ -1,58 +0,0 @@
-/*
- * CommunityDetectionAlgorithm.hpp
- *
- *  Created on: 30.10.2012
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_COMMUNITY_COMMUNITY_DETECTION_ALGORITHM_HPP_
-#define NETWORKIT_COMMUNITY_COMMUNITY_DETECTION_ALGORITHM_HPP_
-
-#include <networkit/base/Algorithm.hpp>
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Abstract base class for community detection/graph clustering algorithms.
- */
-class CommunityDetectionAlgorithm : public Algorithm {
-public:
-    /**
-     * A community detection algorithm operates on a graph, so the constructor expects a graph.
-     *
-     * @param[in] G input graph
-     */
-    CommunityDetectionAlgorithm(const Graph &G);
-
-    /**
-     * A community detection algorithm operates on a graph, so the constructor expects a graph.
-     *
-     * @param[in] G input graph
-     * @param[in] baseClustering optional; the algorithm will start from the given clustering.
-     */
-    CommunityDetectionAlgorithm(const Graph &G, Partition baseClustering);
-
-    /** Default destructor */
-    ~CommunityDetectionAlgorithm() override = default;
-
-    /**
-     * Apply algorithm to graph
-     */
-    void run() override = 0;
-
-    /**
-     * Returns the result of the run method or throws an error, if the algorithm hasn't run yet.
-     * @return partition of the node set
-     */
-    virtual const Partition &getPartition() const;
-
-protected:
-    const Graph *G;
-    Partition result;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_COMMUNITY_DETECTION_ALGORITHM_HPP_

package/vendor/include/networkit/community/Conductance.hpp

@@ -1,32 +0,0 @@
-/*
- * Conductance.hpp
- *
- *  Created on: 26.02.2014
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_COMMUNITY_CONDUCTANCE_HPP_
-#define NETWORKIT_COMMUNITY_CONDUCTANCE_HPP_
-
-#include <networkit/auxiliary/NumericTools.hpp>
-#include <networkit/community/EdgeCut.hpp>
-#include <networkit/community/QualityMeasure.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Compute conductance of a 2-partition, i.e. cut size over volume of smaller set (smaller in
- * terms of volume).
- */
-class Conductance final : public QualityMeasure {
-public:
-    /**
-     * @return Conductance of 2-partition @a zeta in graph @a G.
-     * Requires cluster IDs to be either 0 or 1.
-     */
-    double getQuality(const Partition &zeta, const Graph &G) override;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_CONDUCTANCE_HPP_

package/vendor/include/networkit/community/CoverF1Similarity.hpp

@@ -1,53 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_COVER_F1_SIMILARITY_HPP_
-#define NETWORKIT_COMMUNITY_COVER_F1_SIMILARITY_HPP_
-
-#include <networkit/community/LocalCoverEvaluation.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Compare a given cover to a reference cover using the F1 measure.
- * This is a typical similarity measure used to compare the found
- * overlapping community structure to a ground truth community
- * structure. Each cluster is compared to the best-matching reference
- * cluster (in terms of highest F1 score). A value of 1 indicates
- * perfect agreement while a while of 0 indicates complete
- * disagreement. An example where this measure is used is the
- * following paper:
- *
- * Alessandro Epasto, Silvio Lattanzi, and Renato Paes
- * Leme. 2017. Ego-Splitting Framework: from Non-Overlapping to
- * Overlapping Clusters. In Proceedings of the 23rd ACM SIGKDD
- * International Conference on Knowledge Discovery and Data Mining
- * (KDD '17). ACM, New York, NY, USA, 145-154. DOI:
- * https://doi.org/10.1145/3097983.3098054
- */
-class CoverF1Similarity final : public LocalCoverEvaluation {
-public:
-    /**
-     * Initialize the cover F1 similarity.
-     *
-     * @param G The graph on which the evaluation is performed.
-     * @param C The cover that shall be evaluated.
-     * @param reference The reference cover to which @a C shall be compared.
-     */
-    CoverF1Similarity(const Graph &G, const Cover &C, const Cover &reference);
-
-    /**
-     * Execute the algorithm. The algorithm is not parallel.
-     */
-    void run() override;
-
-    /**
-     * @return false - smaller is not better, larger values indicate better matching clusters.
-     */
-    bool isSmallBetter() const override { return false; }
-
-private:
-    const Cover *reference;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_COVER_F1_SIMILARITY_HPP_

package/vendor/include/networkit/community/CoverHubDominance.hpp

@@ -1,38 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_COVER_HUB_DOMINANCE_HPP_
-#define NETWORKIT_COMMUNITY_COVER_HUB_DOMINANCE_HPP_
-
-#include <networkit/community/LocalCoverEvaluation.hpp>
-
-namespace NetworKit {
-
-/**
- * A quality measure that measures the dominance of hubs in clusters. The hub dominance of a single
- * cluster is defined as the maximum cluster-internal degree of a node in that cluster divided by
- * the maximum cluster-internal degree, i.e. the number of nodes in the cluster minus one. The
- * value for all clusters is defined as the average of all clusters.
- * This implementation is a natural generalization of this measure for covers.
- * Strictly speaking this is not a quality measure as this is rather dependent on the type of the
- * considered graph, for more information see
- * Lancichinetti A, Kivel M, Saramki J, Fortunato S (2010)
- * Characterizing the Community Structure of Complex Networks
- * PLoS ONE 5(8): e11976. doi: 10.1371/journal.pone.0011976
- * http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0011976
- */
-class CoverHubDominance final : public LocalCoverEvaluation {
-public:
-    using LocalCoverEvaluation::LocalCoverEvaluation;
-
-    /**
-     * Execute the algorithm. The algorithm is not parallel.
-     */
-    void run() override;
-
-    /**
-     * @return false - smaller is not better, larger values indicate better cluster cohesion.
-     */
-    bool isSmallBetter() const override { return false; }
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_COVER_HUB_DOMINANCE_HPP_

package/vendor/include/networkit/community/Coverage.hpp

@@ -1,25 +0,0 @@
-/*
- * Coverage.hpp
- *
- *  Created on: 02.02.2013
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_COMMUNITY_COVERAGE_HPP_
-#define NETWORKIT_COMMUNITY_COVERAGE_HPP_
-
-#include <networkit/community/QualityMeasure.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Coverage is the fraction of intra-cluster edges.
- */
-class Coverage final : public QualityMeasure {
-public:
-    double getQuality(const Partition &zeta, const Graph &G) override;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_COVERAGE_HPP_

package/vendor/include/networkit/community/CutClustering.hpp

@@ -1,62 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_CUT_CLUSTERING_HPP_
-#define NETWORKIT_COMMUNITY_CUT_CLUSTERING_HPP_
-
-#include <networkit/community/CommunityDetectionAlgorithm.hpp>
-
-namespace NetworKit {
-
-/**
- * Cut clustering algorithm as defined in
- * Flake, Gary William; Tarjan, Robert E.; Tsioutsiouliklis, Kostas. Graph Clustering and Minimum
- * Cut Trees. Internet Mathematics 1 (2003), no. 4, 385--408.
- */
-class CutClustering final : public CommunityDetectionAlgorithm {
-public:
-    /**
-     * Initialize cut clustering algorithm with parameter alpha.
-     *
-     * A value of 0 gives a clustering with one cluster with all nodes,
-     * A value that equals to the largest edge weight gives singleton clusters.
-     *
-     * @param alpha The parameter for the cut clustering
-     */
-    CutClustering(const Graph &G, edgeweight alpha);
-
-    /**
-     * Apply algorithm to graph
-     *
-     * Warning: due to numerical errors the resulting clusters might not be correct.
-     * This implementation uses the Edmonds-Karp algorithm for the cut calculation.
-     */
-    void run() override;
-
-    /**
-     * Get the complete hierarchy with all possible parameter values.
-     *
-     * Each reported parameter value is the lower bound for the range in which the corresponding
-     * clustering is calculated by the cut clustering algorithm.
-     *
-     * Warning: all reported parameter values are slightly too high in order to avoid wrong
-     * clusterings because of numerical inaccuracies. Furthermore the completeness of the hierarchy
-     * cannot be guaranteed because of these inaccuracies. This implementation hasn't been optimized
-     * for performance.
-     *
-     * @param G The Graph instance for which the hierarchy shall be calculated
-     *
-     * @return The hierarchy as map
-     */
-    static std::map<edgeweight, Partition> getClusterHierarchy(const Graph &G);
-
-private:
-    /**
-     * Helper function for the recursive clustering hierarchy calculation.
-     */
-    static void clusterHierarchyRecursion(const Graph &G, edgeweight lower, Partition lowerClusters,
-                                          edgeweight upper, Partition upperClusters,
-                                          std::map<edgeweight, Partition> &result);
-    edgeweight alpha;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_CUT_CLUSTERING_HPP_

package/vendor/include/networkit/community/DissimilarityMeasure.hpp

@@ -1,31 +0,0 @@
-/*
- * DissimilarityMeasure.hpp
- *
- *  Created on: 19.01.2013
- *      Author: Christian Staudt
- */
-
-#ifndef NETWORKIT_COMMUNITY_DISSIMILARITY_MEASURE_HPP_
-#define NETWORKIT_COMMUNITY_DISSIMILARITY_MEASURE_HPP_
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/structures/Cover.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * Base class for all clustering dissimilarity measures.
- */
-class DissimilarityMeasure {
-
-public:
-    virtual double getDissimilarity(const Graph &G, const Partition &first,
-                                    const Partition &second) = 0;
-
-    virtual double getDissimilarity(const Graph &G, const Cover &first, const Cover &second);
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_DISSIMILARITY_MEASURE_HPP_

package/vendor/include/networkit/community/DynamicNMIDistance.hpp

@@ -1,44 +0,0 @@
-/*
- * DynamicNMIDistance.hpp
- *
- *  Created on: Jun 26, 2013
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_COMMUNITY_DYNAMIC_NMI_DISTANCE_HPP_
-#define NETWORKIT_COMMUNITY_DYNAMIC_NMI_DISTANCE_HPP_
-
-#include <networkit/community/DissimilarityMeasure.hpp>
-#include <networkit/community/NMIDistance.hpp>
-
-namespace NetworKit {
-
-using Matrix = std::vector<std::vector<count>>;
-
-/**
- * @ingroup community
- */
-class DynamicNMIDistance final : public DissimilarityMeasure {
-public:
-    /**
-     * Computes NMI between two clusterings that belong to two different graphs.
-     * @a newGraph has evolved from oldGraph, which is only given implicitly via
-     * @a oldClustering. NMI is only applied to nodes that belong to the intersection
-     * of oldGraph and @a newGraph. Nodes of oldGraph not existing in @newGraph are
-     * marked by the entry none in @a newClustering.
-     */
-    double getDissimilarity(const Graph &newGraph, const Partition &oldClustering,
-                            const Partition &newClustering) override;
-
-    void combineValues(double H_sum, double MI, double &NMI, double &NMID) const;
-    void sanityCheck(double &NMI, double &NMID) const;
-
-    double entropy(const Partition &clustering, count n, std::vector<double> probs);
-
-    bool isInBoth(node u, const Partition &oldClustering, const Partition &newClustering);
-
-    Matrix confusionMatrix(const Graph &G, const Partition &zeta, const Partition &eta);
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_DYNAMIC_NMI_DISTANCE_HPP_

package/vendor/include/networkit/community/EdgeCut.hpp

@@ -1,24 +0,0 @@
-/*
- * EdgeCut.hpp
- *
- *  Created on: Jun 20, 2013
- *      Author: Henning
- */
-
-#ifndef NETWORKIT_COMMUNITY_EDGE_CUT_HPP_
-#define NETWORKIT_COMMUNITY_EDGE_CUT_HPP_
-
-#include <networkit/community/QualityMeasure.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- */
-class EdgeCut final : public QualityMeasure {
-public:
-    double getQuality(const Partition &zeta, const Graph &G) override;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_EDGE_CUT_HPP_

package/vendor/include/networkit/community/GraphClusteringTools.hpp

@@ -1,103 +0,0 @@
-/*
- * GraphClusteringTools.hpp
- */
-
-#ifndef NETWORKIT_COMMUNITY_GRAPH_CLUSTERING_TOOLS_HPP_
-#define NETWORKIT_COMMUNITY_GRAPH_CLUSTERING_TOOLS_HPP_
-
-#include <networkit/graph/Graph.hpp>
-#include <networkit/graph/GraphW.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- */
-namespace GraphClusteringTools {
-
-/**
- * Get the imbalance of clusters in the given partition.
- *
- * @param zeta Input partition
- * @return total imbalance between clusters
- */
-float getImbalance(const Partition &zeta);
-
-/**
- * Get the imbalance of clusters in the given partition compared to a given graph.
- *
- * @param zeta Input partition
- * @param graph Input graph
- * @return total imbalance between clusters
- */
-float getImbalance(const Partition &zeta, const Graph &graph);
-
-/**
- * Get the communication graph for a given graph and its partition.
- * A communication graph consists of a number of nodes, which equal
- * the number of clusters in the partition. The edges between nodes
- * in the communication graph account for the total edge weight for all
- * edges between two clusters. For unweighted graphs, the edge weight in
- * the communication graph is equal to the number of edges between two
- * clusters.
- *
- * @param graph The input graph
- * @param zeta Partition, which contains information about clusters in the graph
- * @return communication graph
- */
-GraphW communicationGraph(const Graph &graph, Partition &zeta);
-
-/**
- * Get weightedDegree of node u for a cluster (represented by a partition) of index cid.
- *
- * @param graph The input graph
- * @param zeta Partition, which contains information about clusters in the graph
- * @param u node
- * @param cid index of cluster
- * @return weighted degree of node u for cluster index cid
- */
-edgeweight weightedDegreeWithCluster(const Graph &graph, const Partition &zeta, node u, index cid);
-
-/**
- * Check whether a partition is a proper clustering for a given graph
- *
- * @param graph The input graph
- * @param zeta Partition, which contains information about clusters in the graph
- * @return True if the partition is a proper clustering, False if not
- */
-bool isProperClustering(const Graph &G, const Partition &zeta);
-
-/**
- * Check whether a partition is a proper singleton clustering for a given graph
- *
- * @param graph The input graph
- * @param zeta Partition, which contains information about clusters in the graph
- * @return True if the partition is a proper singleton clustering, False if not
- */
-bool isSingletonClustering(const Graph &G, const Partition &zeta);
-
-/**
- * Check whether a partition is a proper one clustering for a given graph
- *
- * @param graph The input graph
- * @param zeta Partition, which contains information about clusters in the graph
- * @return True if the partition is a proper one clustering, False if not
- */
-bool isOneClustering(const Graph &G, const Partition &zeta);
-
-/**
- * Check whether two paritions are equal for a given graph
- *
- * @param graph The input graph
- * @param zeta Partition, which contains information about clusters in the graph
- * @param eta Partition, which contains information about clusters in the graph
- * @return True if both partitions are the same, False if not
- */
-bool equalClusterings(const Partition &zeta, const Partition &eta, Graph &G);
-
-} // namespace GraphClusteringTools
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_GRAPH_CLUSTERING_TOOLS_HPP_

package/vendor/include/networkit/community/GraphStructuralRandMeasure.hpp

@@ -1,28 +0,0 @@
-/*
- * GraphStructuralRandMeasure.hpp
- *
- *  Created on: 16.04.2013
- *      Author: cls
- */
-
-#ifndef NETWORKIT_COMMUNITY_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_
-#define NETWORKIT_COMMUNITY_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_
-
-#include <networkit/community/DissimilarityMeasure.hpp>
-
-namespace NetworKit {
-
-/**
- * @ingroup community
- * The graph-structural Rand measure assigns a similarity value in [0,1]
- * to two partitions of a graph, by considering connected pairs of nodes.
- */
-class GraphStructuralRandMeasure final : public DissimilarityMeasure {
-
-public:
-    double getDissimilarity(const Graph &G, const Partition &first,
-                            const Partition &second) override;
-};
-
-} /* namespace NetworKit */
-#endif // NETWORKIT_COMMUNITY_GRAPH_STRUCTURAL_RAND_MEASURE_HPP_

package/vendor/include/networkit/community/HubDominance.hpp

@@ -1,46 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_HUB_DOMINANCE_HPP_
-#define NETWORKIT_COMMUNITY_HUB_DOMINANCE_HPP_
-
-#include <networkit/community/QualityMeasure.hpp>
-#include <networkit/structures/Cover.hpp>
-#include <networkit/structures/Partition.hpp>
-
-namespace NetworKit {
-
-/**
- * A quality measure that measures the dominance of hubs in clusters. The hub dominance of a single
- * cluster is defined as the maximum cluster-internal degree of a node in that cluster divided by
- * the maximum cluster-internal degree, i.e. the number of nodes in the cluster minus one. The
- * value for all clusters is defined as the average of all clusters.
- * Strictly speaking this is not a quality measure as this is rather dependent on the type of the
- * considered graph, for more information see
- * Lancichinetti A, Kivel M, Saramki J, Fortunato S (2010)
- * Characterizing the Community Structure of Complex Networks
- * PLoS ONE 5(8): e11976. doi: 10.1371/journal.pone.0011976
- * http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0011976
- */
-class HubDominance final : public QualityMeasure {
-public:
-    /**
-     * Calculates the dominance of hubs in the given Partition @a zeta of the given
-     * Graph @a G.
-     *
-     * @param zeta The partition for which the hub dominance shall be calculated
-     * @param G The graph that is partitioned in @a zeta
-     * @return The average hub dominance of @a zeta
-     */
-    double getQuality(const Partition &zeta, const Graph &G) override;
-    /**
-     * Calculates the dominance of hubs in the given Cover @a zeta of the given
-     * Graph @a G.
-     *
-     * @param zeta The cover for which the hub dominance shall be calculated
-     * @param G The graph that is partitioned in @a zeta
-     * @return The average hub dominance of @a zeta
-     */
-    double getQuality(const Cover &zeta, const Graph &G);
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_HUB_DOMINANCE_HPP_

package/vendor/include/networkit/community/IntrapartitionDensity.hpp

@@ -1,44 +0,0 @@
-#ifndef NETWORKIT_COMMUNITY_INTRAPARTITION_DENSITY_HPP_
-#define NETWORKIT_COMMUNITY_INTRAPARTITION_DENSITY_HPP_
-
-#include <networkit/community/LocalPartitionEvaluation.hpp>
-
-namespace NetworKit {
-
-/**
- * The intra-cluster density of a partition is defined as the number of existing edges divided by
- * the number of possible edges. The global value is the sum of all existing intra-cluster edges
- * divided by the sum of all possible intra-cluster edges.
- */
-class IntrapartitionDensity final : public LocalPartitionEvaluation {
-public:
-    using LocalPartitionEvaluation::LocalPartitionEvaluation;
-
-    /**
-     * Execute the algorithm. The algorithm is not parallel.
-     */
-    void run() override;
-
-    /**
-     * Get the global intra-cluster density.
-     *
-     * @return The global intra-cluster density.
-     */
-    double getGlobal() const {
-        assureFinished();
-        return globalValue;
-    };
-
-    /**
-     * This value should be high in a good clustering.
-     * @return false - high values are better than small values.
-     */
-    bool isSmallBetter() const override { return false; }
-
-private:
-    double globalValue;
-};
-
-} // namespace NetworKit
-
-#endif // NETWORKIT_COMMUNITY_INTRAPARTITION_DENSITY_HPP_