├── .gitignore
├── main
├── HDBSCAN-CPP
    ├── Runner
    │   ├── hdbscanParameters.cpp
    │   ├── hdbscanRunner.hpp
    │   ├── hdbscanResult.cpp
    │   ├── hdbscanResult.hpp
    │   ├── hdbscanParameters.hpp
    │   └── hdbscanRunner.cpp
    ├── Distance
    │   ├── IDistanceCalculator.cpp
    │   ├── ManhattanDistance.hpp
    │   ├── EuclideanDistance.hpp
    │   ├── ManhattanDistance.cpp
    │   ├── EuclideanDistance.cpp
    │   └── IDistanceCalculator.hpp
    ├── run.sh
    ├── README.md
    ├── Utils
    │   ├── bitSet.hpp
    │   └── bitSet.cpp
    ├── HdbscanStar
    │   ├── hdbscanConstraint.cpp
    │   ├── outlierScore.cpp
    │   ├── hdbscanConstraint.hpp
    │   ├── outlierScore.hpp
    │   ├── cluster.hpp
    │   ├── undirectedGraph.hpp
    │   ├── undirectedGraph.cpp
    │   ├── cluster.cpp
    │   ├── hdbscanAlgorithm.hpp
    │   └── hdbscanAlgorithm.cpp
    ├── Hdbscan
    │   ├── hdbscan.hpp
    │   └── hdbscan.cpp
    ├── .vscode
    │   ├── launch.json
    │   └── tasks.json
    ├── .gitattributes
    └── .gitignore
├── Makefile
├── .travis.yml
├── HDBSCAN-FourProminentClusterExample
    └── FourProminentClusterExample.cpp
├── LICENSE.md
├── README.md
└── HDBSCANDataset
    └── FourProminentClusterDataset.csv


/.gitignore:
--------------------------------------------------------------------------------
1 | HDBSCANUnitTest/Debug
2 | HDBSCAN-CPP/Debug


--------------------------------------------------------------------------------
/main:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rohanmohapatra/hdbscan-cpp/HEAD/main


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Runner/hdbscanParameters.cpp:
--------------------------------------------------------------------------------
1 | #include "hdbscanParameters.hpp"
2 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Distance/IDistanceCalculator.cpp:
--------------------------------------------------------------------------------
1 | #pragma once
2 | #include"IDistanceCalculator.hpp"


--------------------------------------------------------------------------------
/HDBSCAN-CPP/run.sh:
--------------------------------------------------------------------------------
1 | g++ -c -g -O3 */*.cpp
2 | g++ -g -O3 main.cpp *.o
3 | ./a.out
4 | rm  *.o
5 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/README.md:
--------------------------------------------------------------------------------
1 | # hdbscan-cpp
2 | Fast and Efficient Implementation of HDBSCAN in C++ using STL
3 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Runner/hdbscanRunner.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include"hdbscanResult.hpp"
 3 | #include"hdbscanParameters.hpp"
 4 | class hdbscanRunner
 5 | {
 6 | public:
 7 | 	static hdbscanResult run(hdbscanParameters parameters);
 8 | };
 9 | 
10 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Utils/bitSet.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include<vector>
 3 | class bitSet
 4 | {
 5 | private:
 6 | 	std::vector<bool> _bits;
 7 | public:
 8 | 	bool get(int pos);
 9 | 	
10 | 	void set(int pos);
11 | 
12 | 	void ensure(int pos);
13 | };
14 | 
15 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | SOURCES=$(shell find . -name "*.cpp")
 2 | CXXFLAGS= -std=c++11 -Wall
 3 | OBJECTS=$(SOURCES:%.cpp=%.o)
 4 | TARGET=main
 5 | 
 6 | .PHONY: all
 7 | all: $(TARGET)
 8 | 
 9 | $(TARGET): $(OBJECTS)
10 | 	$(LINK.cpp) $^ -std=c++11 $(LOADLIBES) $(LDLIBS) -o $@
11 | 
12 | .PHONY: clean
13 | clean:
14 | 	rm -f $(OBJECTS)
15 | 
16 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Utils/bitSet.cpp:
--------------------------------------------------------------------------------
 1 | #include "bitSet.hpp"
 2 | 
 3 | 
 4 | bool bitSet::get(int pos) {
 5 | 		return pos < _bits.size() && _bits[pos];
 6 | }
 7 | 
 8 | void bitSet::set(int pos) {
 9 | 		ensure(pos);
10 | 		_bits[pos] = true;
11 | }
12 | 
13 | void bitSet::ensure(int pos) {
14 | 	if (pos >= _bits.size())
15 | 	{
16 | 		_bits.resize(pos + 64);
17 | 	}
18 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Distance/ManhattanDistance.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include"IDistanceCalculator.hpp"
 3 | /// <summary>
 4 | /// Computes the manhattan distance between two points, d = |x1-y1| + |x2-y2| + ... + |xn-yn|.
 5 | /// </summary>
 6 | class ManhattanDistance : IDistanceCalculator
 7 | {
 8 | public:
 9 | 	double computeDistance(std::vector<double> attributesOne, std::vector<double> attributesTwo);
10 | };
11 | 
12 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Distance/EuclideanDistance.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include"IDistanceCalculator.hpp"
 3 | /// <summary>
 4 | /// Computes the euclidean distance between two points, d = sqrt((x1-y1)^2 + (x2-y2)^2 + ... + (xn-yn)^2).
 5 | /// </summary>
 6 | class EuclideanDistance : IDistanceCalculator
 7 | {
 8 | public:
 9 | 	double computeDistance(std::vector<double> attributesOne, std::vector<double> attributesTwo);
10 | 
11 | };
12 | 
13 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Runner/hdbscanResult.cpp:
--------------------------------------------------------------------------------
 1 | #include "hdbscanResult.hpp"
 2 | 
 3 | hdbscanResult::hdbscanResult() {
 4 | 	;
 5 | }
 6 | hdbscanResult::hdbscanResult(vector<int> pLables, vector<outlierScore> pOutlierScores, vector<double> pmembershipProbabilities, bool pHsInfiniteStability) {
 7 | 	labels = pLables;
 8 | 	outliersScores = pOutlierScores;
 9 | 	membershipProbabilities = pmembershipProbabilities;
10 | 	hasInfiniteStability = pHsInfiniteStability;
11 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Distance/ManhattanDistance.cpp:
--------------------------------------------------------------------------------
 1 | #include "ManhattanDistance.hpp"
 2 | #include<vector>
 3 | #include<cmath>
 4 | #include<cstdint>
 5 | double ManhattanDistance::computeDistance(std::vector<double> attributesOne, std::vector<double> attributesTwo) {
 6 | 	double distance = 0;
 7 | 	for (uint32_t i = 0; i < attributesOne.size() && i < attributesTwo.size(); i++) {
 8 | 		distance += fabs(attributesOne[i] - attributesTwo[i]);
 9 | 	}
10 | 
11 | 	return distance;
12 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/hdbscanConstraint.cpp:
--------------------------------------------------------------------------------
 1 | #include "hdbscanConstraint.hpp"
 2 | 
 3 | hdbscanConstraint::hdbscanConstraint(int pointA, int pointB, hdbscanConstraintType type) {
 4 | 	_pointA = pointA;
 5 | 	_pointB = pointB;
 6 | 	_constraintType = type;
 7 | }
 8 | 
 9 | int hdbscanConstraint::getPointA() {
10 | 	return _pointA;
11 | }
12 | 
13 | int hdbscanConstraint::getPointB() {
14 | 	return _pointB;
15 | }
16 | 
17 | hdbscanConstraintType hdbscanConstraint::getConstraintType() {
18 | 	return _constraintType;
19 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Runner/hdbscanResult.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include<vector>
 3 | #include"../HdbscanStar/outlierScore.hpp"
 4 | using namespace std;
 5 | class hdbscanResult
 6 | {
 7 | public:
 8 | 	vector <int> labels;
 9 | 	vector <outlierScore> outliersScores;
10 | 	vector <double> membershipProbabilities;
11 | 	bool hasInfiniteStability;
12 | 	hdbscanResult();
13 | 	hdbscanResult(vector<int> pLables, vector<outlierScore> pOutlierScores, vector <double> pmembershipProbabilities, bool pHsInfiniteStability);
14 | };
15 | 
16 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Distance/EuclideanDistance.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include"EuclideanDistance.hpp"
 3 | #include<vector>
 4 | #include<cmath>
 5 | #include<cstdint>
 6 | double EuclideanDistance::computeDistance(std::vector<double> attributesOne, std::vector<double> attributesTwo) {
 7 | 	double distance = 0;
 8 | 	for (uint32_t i = 0; i < attributesOne.size() && i < attributesTwo.size(); i++) {
 9 | 		distance += ((attributesOne[i] - attributesTwo[i]) * (attributesOne[i] - attributesTwo[i]));
10 | 	}
11 | 
12 | 	return sqrt(distance);
13 | }


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | # Enable C++ support
 2 | language: cpp
 3 | 
 4 | # Compiler selection
 5 | compiler:
 6 |   - g++ 
 7 |   - gcc
 8 |   
 9 | before_install:
10 |   - pip install --user cpp-coveralls
11 |   
12 | sudo: required
13 | script:
14 |   - sudo unlink /usr/bin/g++ && sudo ln -s /usr/bin/g++-5 /usr/bin/g++
15 |   - sudo unlink /usr/bin/gcc && sudo ln -s /usr/bin/gcc-5 /usr/bin/gcc
16 |   - gcc --version
17 |   - make all clean  
18 |   
19 | after_success:
20 |   - coveralls --gcov-options '\-lp'
21 |   
22 | 
23 | addons:
24 |   apt:
25 |     sources:
26 |     - ubuntu-toolchain-r-test
27 |     packages:
28 |     - gcc-5
29 |     - g++-5
30 | 


--------------------------------------------------------------------------------
/HDBSCAN-FourProminentClusterExample/FourProminentClusterExample.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstdio>
 3 | #include"../HDBSCAN-CPP/Hdbscan/hdbscan.hpp"
 4 | using namespace std;
 5 | 
 6 | 
 7 | int main() {
 8 | 	Hdbscan hdbscan("HDBSCANDataset/FourProminentClusterDataset.csv");
 9 | 	hdbscan.loadCsv(2);
10 | 	vector<vector <double>> dataset = hdbscan.dataset;
11 | 	hdbscan.execute(5, 5, "Euclidean");
12 | 	hdbscan.displayResult();
13 | 	cout << "You can access other fields like cluster labels, membership probabilities and outlier scores."<<endl;
14 | 	/*Use it like this
15 | 	hdbscan.labels_;
16 | 	hdbscan.membershipProbabilities_;
17 | 	hdbscan.outlierScores_;
18 | 	*/
19 | 
20 | 	return 0;
21 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/outlierScore.cpp:
--------------------------------------------------------------------------------
 1 | #include "outlierScore.hpp"
 2 | #include <tuple> 
 3 | 
 4 | outlierScore::outlierScore() {
 5 | 	;
 6 | }
 7 | 
 8 | outlierScore::outlierScore(double score, double coreDistance, int id) {
 9 | 	outlierScore::score = score;
10 | 	outlierScore::coreDistance = coreDistance;
11 | 	outlierScore::id = id;
12 | }
13 | 
14 | bool outlierScore::operator<(const outlierScore& other) const {
15 | 	/*
16 | 	if (score < other.score)
17 | 		return score < other.score;
18 | 	else if (coreDistance < other.coreDistance)
19 | 		return coreDistance < other.coreDistance;
20 | 	else if (id < other.id)
21 | 		return id < other.id;
22 | 	else
23 | 		return false;*/
24 | 	return std::tie(score, coreDistance, id) < std::tie(other.score, other.coreDistance, other.id);
25 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Distance/IDistanceCalculator.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include<vector>
 3 | /// <summary>
 4 | /// An interface for classes which compute the distance between two points (where points are
 5 | /// represented as arrays of doubles).
 6 | /// </summary>
 7 | class IDistanceCalculator
 8 | {
 9 | 	/// <summary>
10 | 	/// Computes the distance between two points.
11 | 	/// Note that larger values indicate that the two points are farther apart.
12 | 	/// </summary>
13 | 	/// <param name="attributesOne">The attributes of the first point</param>
14 | 	/// <param name="attributesTwo">The attributes of the second point</param>
15 | 	/// <returns>A double for the distance between the two points</returns>
16 | public:
17 | 	virtual double computeDistance(std::vector<double> attributesOne, std::vector<double> attributesTwo)=0;
18 | };
19 | 
20 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/hdbscanConstraint.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | enum hdbscanConstraintType{mustLink, cannotLink};
 3 | /// <summary>
 4 | /// A clustering constraint (either a must-link or cannot-link constraint between two points).
 5 | /// </summary>
 6 | class hdbscanConstraint
 7 | {
 8 | private : 
 9 | 	hdbscanConstraintType _constraintType;
10 | 	int _pointA;
11 | 	int _pointB;
12 | /// <summary>
13 | /// Creates a new constraint.
14 | /// </summary>
15 | /// <param name="pointA">The first point involved in the constraint</param>
16 | /// <param name="pointB">The second point involved in the constraint</param>
17 | /// <param name="type">The constraint type</param>
18 | public:
19 | 	hdbscanConstraint(int pointA, int pointB, hdbscanConstraintType type);
20 | 
21 | 	int getPointA();
22 | 
23 | 	int getPointB();
24 | 
25 | 	hdbscanConstraintType getConstraintType();
26 | 
27 | };
28 | 
29 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/outlierScore.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 	/// <summary>
 3 | 	/// Simple storage class that keeps the outlier score, core distance, and id (index) for a single point.
 4 | 	/// OutlierScores are sorted in ascending order by outlier score, with core distances used to break
 5 | 	/// outlier score ties, and ids used to break core distance ties.
 6 | 	/// </summary>
 7 | class outlierScore
 8 | {
 9 | private:
10 | 	double coreDistance;
11 | public:
12 | 	double score;
13 | 	int id;
14 | 	/// <summary>
15 | 	/// Creates a new OutlierScore for a given point.
16 | 	/// </summary>
17 | 	/// <param name="score">The outlier score of the point</param>
18 | 	/// <param name="coreDistance">The point's core distance</param>
19 | 	/// <param name="id">The id (index) of the point</param>
20 | 	outlierScore(double score, double coreDistance, int id);
21 | 	outlierScore();
22 | 	/// <summary>
23 | 	/// Method Overridden to compare two objects.
24 | 	/// </summary>
25 | 	bool operator<(const outlierScore& other) const;
26 | 
27 | 
28 | };
29 | 
30 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Hdbscan/hdbscan.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include<string>
 3 | #include<vector>
 4 | #include"../Runner/hdbscanRunner.hpp"
 5 | #include"../Runner/hdbscanParameters.hpp"
 6 | #include"../Runner/hdbscanResult.hpp"
 7 | #include"../HdbscanStar/outlierScore.hpp"
 8 | 
 9 | using namespace std;
10 | 
11 | 
12 | class Hdbscan
13 | 
14 | {
15 | 
16 | private:
17 | 
18 | 	string fileName;
19 | 
20 | 	hdbscanResult result;
21 | 
22 | public:
23 | 
24 | 	vector < vector <double > > dataset;
25 | 
26 | 	std::vector<int> labels_;
27 | 
28 | 	std::vector<int> normalizedLabels_;
29 | 
30 | 	std::vector<outlierScore>outlierScores_;
31 | 
32 | 	std::vector <double> membershipProbabilities_;
33 | 
34 | 	uint32_t noisyPoints_;
35 | 
36 | 	uint32_t numClusters_;
37 | 
38 | 
39 | 
40 | 	Hdbscan(string readFileName) {
41 | 
42 | 		fileName = readFileName;
43 | 
44 | 	}
45 | 
46 | 	string getFileName();
47 | 			   
48 | 	int loadCsv(int numberOfValues, bool skipHeader=false);
49 | 
50 | 	void execute(int minPoints, int minClusterSize, string distanceMetric);
51 | 
52 | 	void displayResult();
53 | 
54 | 
55 | };
56 | 
57 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Use IntelliSense to learn about possible attributes.
 3 |     // Hover to view descriptions of existing attributes.
 4 |     // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 |     "version": "0.2.0",
 6 |     "configurations": [
 7 |         
 8 |         {
 9 |             "name": "g++ build and debug active file",
10 |             "type": "cppdbg",
11 |             "request": "launch",
12 |             "program": "${workspaceFolder}/a.out",
13 |             "args": [],
14 |             "stopAtEntry": false,
15 |             "cwd": "${workspaceFolder}",
16 |             "environment": [],
17 |             "externalConsole": false,
18 |             "MIMode": "gdb",
19 |             "setupCommands": [
20 |                 {
21 |                     "description": "Enable pretty-printing for gdb",
22 |                     "text": "-enable-pretty-printing",
23 |                     "ignoreFailures": true
24 |                 }
25 |             ],
26 |             "preLaunchTask": "g++ build active file",
27 |             "miDebuggerPath": "/usr/bin/gdb"
28 |         }
29 |     ]
30 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Runner/hdbscanParameters.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include<cstdint>
 3 | #include"../Distance/IDistanceCalculator.hpp"
 4 | #include<iostream>
 5 | #include<vector>
 6 | #include"../HdbscanStar/hdbscanConstraint.hpp"
 7 | 
 8 | using namespace std;
 9 | class hdbscanParameters
10 | {
11 | public:
12 | 
13 | 	/// <summary>
14 | 	/// Parameters to be Passed to the HDBSCAN Algorithm
15 | 	/// </summary>
16 | 	/// <param name="distances">The attributes of the first point</param>
17 | 	/// <param name="dataset">The attributes of the second point</param>
18 | 	/// <param name="dataset">The attributes of the second point</param>
19 | 	/// <param name="distanceFunction">Defines the type of distance measure to use : Euclidean, Manhattan ,..</param>
20 | 	/// <param name="minPoints">Min Points in the cluster</param>
21 | 	/// <param name="minClusterSize">The minimum number of points which a cluster needs to be a valid cluster</param>
22 | 	vector< vector <double> > distances;
23 | 	vector< vector <double> > dataset;
24 | 	string distanceFunction;
25 | 	uint32_t minPoints;
26 | 	uint32_t minClusterSize;
27 | 	vector<hdbscanConstraint> constraints;
28 | };
29 | 
30 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 Rohan Mohapatra, Sumedh Basarkod
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/cluster.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <set>
 3 | #include <vector>
 4 | #include <limits>
 5 | #include <stdexcept>
 6 | 
 7 | class cluster
 8 | {
 9 | private:
10 | 	int _id;
11 | 	double _birthLevel;
12 | 	double _deathLevel;
13 | 	int _numPoints;
14 | 	double _propagatedStability;
15 | 	int _numConstraintsSatisfied;
16 | 	int _propagatedNumConstraintsSatisfied;
17 | 	std::set<int> _virtualChildCluster;
18 | 	static int counter;
19 | 
20 | public:
21 | 	std::vector<cluster*> PropagatedDescendants;
22 | 	double PropagatedLowestChildDeathLevel;
23 | 	cluster* Parent;
24 | 	double Stability;
25 | 	bool HasChildren;
26 | 	int Label;
27 | 	int HierarchyPosition;   //First level where points with this cluster's label appear
28 | 
29 | 	cluster();
30 | 
31 | 	cluster(int label, cluster *parent, double birthLevel, int numPoints);
32 | 	bool operator==(const cluster& other) const;
33 | 	void detachPoints(int numPoints, double level);
34 | 	void propagate();
35 | 	void addPointsToVirtualChildCluster(std::set<int> points);
36 | 	
37 | 	bool virtualChildClusterConstraintsPoint(int point);
38 | 
39 | 	void addVirtualChildConstraintsSatisfied(int numConstraints);
40 | 	
41 | 
42 | 	void addConstraintsSatisfied(int numConstraints);
43 | 
44 | 
45 | 	void releaseVirtualChildCluster();
46 | 
47 | 	int getClusterId();
48 | 
49 | };
50 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/undirectedGraph.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include<vector>
 3 | class undirectedGraph
 4 | {
 5 | private:
 6 | 	int _numVertices;
 7 | 	std::vector<int> _verticesA;
 8 | 	std::vector<int> _verticesB;
 9 | 	std::vector<double> _edgeWeights;
10 | 	std::vector<std::vector<int>> _edges;
11 | 
12 | public:
13 | 	undirectedGraph(int numVertices, std::vector<int> verticesA, std::vector<int> verticesB, std::vector<double> edgeWeights)
14 | 	{
15 | 		_numVertices = numVertices;
16 | 		_verticesA = verticesA;
17 | 		_verticesB = verticesB;
18 | 		_edgeWeights = edgeWeights;
19 | 		_edges.resize(numVertices);
20 | 		int _edgesLength = _edges.size();
21 | 		int _edgeWeightsLength = _edgeWeights.size();
22 | 		for (int i = 0; i < _edgeWeightsLength; i++)
23 | 		{
24 | 			_edges[_verticesA[i]].push_back(_verticesB[i]);
25 | 
26 | 			if (_verticesA[i] != _verticesB[i])
27 | 				_edges[_verticesB[i]].push_back(_verticesA[i]);
28 | 		}
29 | 
30 | 	}
31 | 
32 | 	void quicksortByEdgeWeight();
33 | 	int getNumVertices();
34 | 
35 | 	int getNumEdges();
36 | 
37 | 	int getFirstVertexAtIndex(int index);
38 | 	int getSecondVertexAtIndex(int index);
39 | 
40 | 	double getEdgeWeightAtIndex(int index);
41 | 	std::vector<int> &getEdgeListForVertex(int vertex);
42 | private:
43 | 	int selectPivotIndex(int startIndex, int endIndex);
44 | 
45 | 	int partition(int startIndex, int endIndex, int pivotIndex);
46 | 	void swapEdges(int indexOne, int indexTwo);
47 | 
48 | };
49 | 
50 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "tasks": [
 3 |         {
 4 |             "type": "shell",
 5 |             "label": "g++ build active file",
 6 |             "command": "/usr/bin/g++",
 7 |             "args": [
 8 |                 "-g",
 9 |                 "${file}",
10 |                 "-o",
11 |                 "*.o"
12 |             ],
13 |             "options": {
14 |                 "cwd": "/usr/bin"
15 |             }
16 |         },
17 |         {
18 |             "type": "shell",
19 |             "label": "g++ build active file",
20 |             "command": "/usr/bin/g++",
21 |             "args": [
22 |                 "-g",
23 |                 "${file}",
24 |                 "-o",
25 |                 "${fileDirname}/${fileBasenameNoExtension}"
26 |             ],
27 |             "options": {
28 |                 "cwd": "/usr/bin"
29 |             },
30 |             "problemMatcher": [
31 |                 "$gcc"
32 |             ]
33 |         },
34 |         {
35 |             "type": "shell",
36 |             "label": "g++ build active file",
37 |             "command": "/usr/bin/g++",
38 |             "args": [
39 |                 "-g",
40 |                 "${file}",
41 |                 "-o",
42 |                 "${fileDirname}/${fileBasenameNoExtension}"
43 |             ],
44 |             "options": {
45 |                 "cwd": "/usr/bin"
46 |             },
47 |             "problemMatcher": [
48 |                 "$gcc"
49 |             ],
50 |             "group": {
51 |                 "kind": "build",
52 |                 "isDefault": true
53 |             }
54 |         }
55 |     ],
56 |     "version": "2.0.0"
57 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/.gitattributes:
--------------------------------------------------------------------------------
 1 | ###############################################################################
 2 | # Set default behavior to automatically normalize line endings.
 3 | ###############################################################################
 4 | * text=auto
 5 | 
 6 | ###############################################################################
 7 | # Set default behavior for command prompt diff.
 8 | #
 9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs     diff=csharp
14 | 
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following 
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | #*.sln       merge=binary
26 | #*.csproj    merge=binary
27 | #*.vbproj    merge=binary
28 | #*.vcxproj   merge=binary
29 | #*.vcproj    merge=binary
30 | #*.dbproj    merge=binary
31 | #*.fsproj    merge=binary
32 | #*.lsproj    merge=binary
33 | #*.wixproj   merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj   merge=binary
36 | #*.wwaproj   merge=binary
37 | 
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | #*.jpg   binary
44 | #*.png   binary
45 | #*.gif   binary
46 | 
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | # 
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the 
52 | # entries below.
53 | ###############################################################################
54 | #*.doc   diff=astextplain
55 | #*.DOC   diff=astextplain
56 | #*.docx  diff=astextplain
57 | #*.DOCX  diff=astextplain
58 | #*.dot   diff=astextplain
59 | #*.DOT   diff=astextplain
60 | #*.pdf   diff=astextplain
61 | #*.PDF   diff=astextplain
62 | #*.rtf   diff=astextplain
63 | #*.RTF   diff=astextplain
64 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Runner/hdbscanRunner.cpp:
--------------------------------------------------------------------------------
 1 | #include "hdbscanRunner.hpp"
 2 | #include "hdbscanResult.hpp"
 3 | #include "hdbscanParameters.hpp"
 4 | #include"../Distance/EuclideanDistance.hpp"
 5 | #include"../Distance/ManhattanDistance.hpp"
 6 | #include"../HdbscanStar/hdbscanAlgorithm.hpp"
 7 | #include"../HdbscanStar/undirectedGraph.hpp"
 8 | #include"../HdbscanStar/cluster.hpp"
 9 | #include"../HdbscanStar/outlierScore.hpp"
10 | 
11 | using namespace hdbscanStar;
12 | 
13 | hdbscanResult hdbscanRunner::run(hdbscanParameters parameters) {
14 | 	int numPoints = parameters.dataset.size() != 0 ? parameters.dataset.size() : parameters.distances.size();
15 | 
16 | 	hdbscanAlgorithm algorithm;
17 | 	hdbscanResult result;
18 | 	if (parameters.distances.size() == 0) {
19 | 		std::vector<std::vector<double>> distances(numPoints);
20 | 		for (int i = 0; i < numPoints; i++) {
21 | 			distances[i].resize(numPoints);
22 | 			//distances[i]=std::vector<double>(numPoints);
23 | 			for (int j = 0; j < i; j++) {
24 | 				if (parameters.distanceFunction.length() == 0) {
25 | 					//Default to Euclidean
26 | 					EuclideanDistance EDistance;
27 | 					double distance;
28 | 					distance = EDistance.computeDistance(parameters.dataset[i], parameters.dataset[j]);
29 | 					distances[i][j] = distance;
30 | 					distances[j][i] = distance;
31 | 
32 | 				}
33 | 				else if (parameters.distanceFunction == "Euclidean") {
34 | 					EuclideanDistance EDistance;
35 | 					double distance;
36 | 					distance = EDistance.computeDistance(parameters.dataset[i], parameters.dataset[j]);
37 | 					distances[i][j] = distance;
38 | 					distances[j][i] = distance;
39 | 				}
40 | 				else if (parameters.distanceFunction == "Manhattan") {
41 | 					ManhattanDistance MDistance;
42 | 					double distance;
43 | 					distance = MDistance.computeDistance(parameters.dataset[i], parameters.dataset[j]);
44 | 					distances[i][j] = distance;
45 | 					distances[j][i] = distance;
46 | 				}
47 | 			}
48 | 		}
49 | 
50 | 		parameters.distances = distances;
51 | 	}
52 | 
53 | 	std::vector <double> coreDistances = algorithm.calculateCoreDistances(
54 | 		parameters.distances,
55 | 		parameters.minPoints);
56 | 
57 | 	undirectedGraph mst = algorithm.constructMst(
58 | 		parameters.distances,
59 | 		coreDistances,
60 | 		true);
61 | 	mst.quicksortByEdgeWeight();
62 | 
63 | 	std::vector<double> pointNoiseLevels(numPoints);
64 | 	std::vector<int> pointLastClusters(numPoints);
65 | 
66 | 	std::vector< std::vector <int> > hierarchy;
67 | 
68 | 	std::vector<cluster*> clusters;
69 | 	algorithm.computeHierarchyAndClusterTree(
70 | 		&mst,
71 | 		parameters.minClusterSize,
72 | 		parameters.constraints,
73 | 		hierarchy,
74 | 		pointNoiseLevels,
75 | 		pointLastClusters,
76 | 		clusters);
77 | 	bool infiniteStability = algorithm.propagateTree(clusters);
78 | 
79 | 	std::vector<int> prominentClusters = algorithm.findProminentClusters(clusters, hierarchy, numPoints);
80 | 	std::vector<double> membershipProbabilities = algorithm.findMembershipScore(prominentClusters, coreDistances);
81 | 	std::vector<outlierScore> scores = algorithm.calculateOutlierScores(
82 | 		clusters,
83 | 		pointNoiseLevels,
84 | 		pointLastClusters,
85 | 		coreDistances);
86 | 
87 | 	return hdbscanResult(prominentClusters, scores, membershipProbabilities,  infiniteStability);
88 | }
89 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/Hdbscan/hdbscan.cpp:
--------------------------------------------------------------------------------
  1 | #include "hdbscan.hpp"
  2 | #include<iostream>
  3 | #include<fstream>
  4 | #include<sstream>
  5 | #include<set>
  6 | #include<map>
  7 | #include<cstdint>
  8 | using namespace std;
  9 | 
 10 | string Hdbscan::getFileName() {
 11 | 	return this->fileName;
 12 | }
 13 | /// <summary>
 14 | ///	Loads the csv file as specified by the constructor.CSV
 15 | /// </summary>
 16 | /// <param name="numberOfalues">A List of attributes to be choosen</param>
 17 | /// <param name="skipHeader">Bool value to skip header or not</param>
 18 | /// <returns>1 if successful, 0 otherwise</returns>
 19 | 
 20 | int Hdbscan::loadCsv(int numberOfValues, bool skipHeader) {
 21 | 	string  attribute;
 22 | 
 23 | 	string line = "";
 24 | 
 25 | 	int currentAttributes;
 26 | 	vector<vector<double> > dataset;
 27 | 
 28 | 	string fileName = this->getFileName();
 29 | 	ifstream file(fileName, ios::in);
 30 | 	if (!file)
 31 | 		return 0;
 32 | 	if (skipHeader) {
 33 | 		getline(file, line);
 34 | 
 35 | 	}
 36 | 	while (getline(file, line)) {      //Read through each line
 37 | 		stringstream s(line);
 38 | 		vector<double> row;
 39 | 		currentAttributes = numberOfValues;
 40 | 		while (getline(s, attribute, ',') && currentAttributes != 0) {
 41 | 			row.push_back(stod(attribute));
 42 | 			currentAttributes--;
 43 | 		}
 44 | 		dataset.push_back(row);
 45 | 
 46 | 	}
 47 | 	this->dataset = dataset;
 48 | 	return 1;
 49 | }
 50 | 
 51 | void Hdbscan::execute(int minPoints, int minClusterSize, string distanceMetric) {
 52 | 	//Call The Runner Class here
 53 | 	hdbscanRunner runner;
 54 | 	hdbscanParameters parameters;
 55 | 	uint32_t noisyPoints = 0;
 56 | 	set<int> numClustersSet;
 57 | 	map<int, int> clustersMap;
 58 | 	vector<int> normalizedLabels;
 59 | 
 60 | 	parameters.dataset = this->dataset;
 61 | 	parameters.minPoints = minPoints;
 62 | 	parameters.minClusterSize = minClusterSize;
 63 | 	parameters.distanceFunction = distanceMetric;
 64 |     	this->result = runner.run(parameters);
 65 | 	this->labels_ = result.labels;
 66 | 	this->outlierScores_ = result.outliersScores;
 67 | 	for (uint32_t i = 0; i < result.labels.size(); i++) {
 68 | 		if (result.labels[i] == 0) {
 69 | 			noisyPoints++;
 70 | 		}
 71 | 		else {
 72 | 			numClustersSet.insert(result.labels[i]);
 73 | 		}
 74 | 	}
 75 | 	this->numClusters_ = numClustersSet.size();
 76 | 	this->noisyPoints_ = noisyPoints;
 77 | 	int iNdex = 1;
 78 | 	for (auto it = numClustersSet.begin(); it != numClustersSet.end(); it++) {
 79 | 		clustersMap[*it] = iNdex++;
 80 | 	}
 81 | 	for (int i = 0; i < labels_.size(); i++) {
 82 | 		if (labels_[i] != 0)
 83 | 			normalizedLabels.push_back(clustersMap[labels_[i]]);
 84 | 		else if (labels_[i] == 0) {
 85 | 			normalizedLabels.push_back(-1);
 86 | 		}
 87 | 
 88 | 	}
 89 | 	this->normalizedLabels_ = normalizedLabels;
 90 | 	this->membershipProbabilities_ = result.membershipProbabilities;
 91 | }
 92 | 
 93 | void Hdbscan::displayResult() {
 94 | 	hdbscanResult result = this->result;
 95 | 	uint32_t numClusters = 0;
 96 | 
 97 | 	cout << "HDBSCAN clustering for " << this->dataset.size() << " objects." << endl;
 98 | 
 99 | 	for (uint32_t i = 0; i < result.labels.size(); i++) {
100 | 		cout << result.labels[i] << " ";
101 | 	}
102 | 
103 | 	cout << endl << endl;
104 | 
105 | 	cout << "The Clustering contains " << this->numClusters_ << " clusters with " << this->noisyPoints_ << " noise Points." << endl;
106 | 
107 | }
108 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/undirectedGraph.cpp:
--------------------------------------------------------------------------------
  1 | #include "undirectedGraph.hpp"
  2 | 
  3 | void undirectedGraph::quicksortByEdgeWeight()
  4 | {
  5 | 	int _edgeWeightsLength = _edgeWeights.size();
  6 | 	if (_edgeWeightsLength <= 1)
  7 | 		return;
  8 | 
  9 | 	std::vector<int> startIndexStack(_edgeWeightsLength / 2);
 10 | 	std::vector<int> endIndexStack(_edgeWeightsLength / 2);
 11 | 
 12 | 	startIndexStack[0] = 0;
 13 | 	endIndexStack[0] = _edgeWeightsLength - 1;
 14 | 
 15 | 	int stackTop = 0;
 16 | 	while (stackTop >= 0)
 17 | 	{
 18 | 		int startIndex = startIndexStack[stackTop];
 19 | 		int endIndex = endIndexStack[stackTop];
 20 | 		stackTop--;
 21 | 		int pivotIndex = selectPivotIndex(startIndex, endIndex);
 22 | 		pivotIndex = partition(startIndex, endIndex, pivotIndex);
 23 | 		if (pivotIndex > startIndex + 1)
 24 | 		{
 25 | 			startIndexStack[stackTop + 1] = startIndex;
 26 | 			endIndexStack[stackTop + 1] = pivotIndex - 1;
 27 | 			stackTop++;
 28 | 		}
 29 | 		if (pivotIndex < endIndex - 1)
 30 | 		{
 31 | 			startIndexStack[stackTop + 1] = pivotIndex + 1;
 32 | 			endIndexStack[stackTop + 1] = endIndex;
 33 | 			stackTop++;
 34 | 		}
 35 | 
 36 | 	}
 37 | }
 38 | int undirectedGraph::selectPivotIndex(int startIndex, int endIndex)
 39 | {
 40 | 	if (startIndex - endIndex <= 1)
 41 | 		return startIndex;
 42 | 
 43 | 	double first = _edgeWeights[startIndex];
 44 | 	double middle = _edgeWeights[startIndex + (endIndex - startIndex) / 2];
 45 | 	double last = _edgeWeights[endIndex];
 46 | 
 47 | 	if (first <= middle)
 48 | 	{
 49 | 		if (middle <= last)
 50 | 			return startIndex + (endIndex - startIndex) / 2;
 51 | 
 52 | 		if (last >= first)
 53 | 			return endIndex;
 54 | 
 55 | 		return startIndex;
 56 | 	}
 57 | 
 58 | 	if (first <= last)
 59 | 		return startIndex;
 60 | 
 61 | 	if (last >= middle)
 62 | 		return endIndex;
 63 | 
 64 | 	return startIndex + (endIndex - startIndex) / 2;
 65 | }
 66 | 
 67 | int undirectedGraph::partition(int startIndex, int endIndex, int pivotIndex)
 68 | {
 69 | 	double pivotValue = _edgeWeights[pivotIndex];
 70 | 	swapEdges(pivotIndex, endIndex);
 71 | 	int lowIndex = startIndex;
 72 | 	for (int i = startIndex; i < endIndex; i++)
 73 | 	{
 74 | 		if (_edgeWeights[i] < pivotValue)
 75 | 		{
 76 | 			swapEdges(i, lowIndex);
 77 | 			lowIndex++;
 78 | 		}
 79 | 	}
 80 | 	swapEdges(lowIndex, endIndex);
 81 | 	return lowIndex;
 82 | }
 83 | 
 84 | void undirectedGraph::swapEdges(int indexOne, int indexTwo)
 85 | {
 86 | 	if (indexOne == indexTwo)
 87 | 		return;
 88 | 
 89 | 	int tempVertexA = _verticesA[indexOne];
 90 | 	int tempVertexB = _verticesB[indexOne];
 91 | 	double tempEdgeDistance = _edgeWeights[indexOne];
 92 | 	_verticesA[indexOne] = _verticesA[indexTwo];
 93 | 	_verticesB[indexOne] = _verticesB[indexTwo];
 94 | 	_edgeWeights[indexOne] = _edgeWeights[indexTwo];
 95 | 	_verticesA[indexTwo] = tempVertexA;
 96 | 	_verticesB[indexTwo] = tempVertexB;
 97 | 	_edgeWeights[indexTwo] = tempEdgeDistance;
 98 | }
 99 | 
100 | int undirectedGraph::getNumVertices()
101 | {
102 | 	return _numVertices;
103 | }
104 | 
105 | int undirectedGraph::getNumEdges()
106 | {
107 | 	return _edgeWeights.size();
108 | }
109 | 
110 | int undirectedGraph::getFirstVertexAtIndex(int index)
111 | {
112 | 	return _verticesA[index];
113 | }
114 | 
115 | int undirectedGraph::getSecondVertexAtIndex(int index)
116 | {
117 | 	return _verticesB[index];
118 | }
119 | 
120 | double undirectedGraph::getEdgeWeightAtIndex(int index)
121 | {
122 | 	return _edgeWeights[index];
123 | }
124 | 
125 | std::vector<int>& undirectedGraph::getEdgeListForVertex(int vertex)
126 | {
127 | 	return _edges[vertex];
128 | }


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/cluster.cpp:
--------------------------------------------------------------------------------
  1 | #include"cluster.hpp"
  2 | #include <iostream>
  3 | int cluster::counter = 0;
  4 | cluster::cluster()
  5 | {
  6 | 
  7 | 	_id = ++counter;
  8 | }
  9 | 
 10 | cluster::cluster(int label, cluster* parent, double birthLevel, int numPoints) //:Label(label), Parent(parent), _birthLevel(birthLevel), _numPoints(numPoints)
 11 | {
 12 | 	_id = ++counter;
 13 | 	_deathLevel = 0;
 14 | 
 15 | 	_propagatedStability = 0;
 16 | 	_numConstraintsSatisfied = 0;
 17 | 	_propagatedNumConstraintsSatisfied = 0;
 18 | 
 19 | 	Parent = parent;
 20 | 	Label = label;
 21 | 	_birthLevel = birthLevel;
 22 | 	_numPoints = numPoints;
 23 | 	HierarchyPosition = 0;
 24 | 	Stability = 0;
 25 | 	PropagatedLowestChildDeathLevel = std::numeric_limits<double>::max();
 26 | 
 27 | 	if (Parent != NULL)
 28 | 		Parent->HasChildren = true;
 29 | 	HasChildren = false;
 30 | 	PropagatedDescendants.resize(0);
 31 | }
 32 | bool cluster ::operator==(const cluster& other) const {
 33 | 	return (this->_id == other._id);
 34 | }
 35 | void cluster::detachPoints(int numPoints, double level)
 36 | {
 37 | 	_numPoints -= numPoints;
 38 | 	Stability += (numPoints * (1 / level - 1 / _birthLevel));
 39 | 
 40 | 	if (_numPoints == 0)
 41 | 		_deathLevel = level;
 42 | 	else if (_numPoints < 0)
 43 | 		throw std::invalid_argument("Cluster cannot have less than 0 points.");
 44 | }
 45 | 
 46 | void cluster::propagate()
 47 | {
 48 | 	if (Parent != NULL)
 49 | 	{
 50 | 		if (PropagatedLowestChildDeathLevel == std::numeric_limits<double>::max())
 51 | 			PropagatedLowestChildDeathLevel = _deathLevel;
 52 | 		if (PropagatedLowestChildDeathLevel < Parent->PropagatedLowestChildDeathLevel)
 53 | 			Parent->PropagatedLowestChildDeathLevel = PropagatedLowestChildDeathLevel;
 54 | 		if (!HasChildren)
 55 | 		{
 56 | 			Parent->_propagatedNumConstraintsSatisfied += _numConstraintsSatisfied;
 57 | 			Parent->_propagatedStability += Stability;
 58 | 			Parent->PropagatedDescendants.push_back(this);
 59 | 		}
 60 | 		else if (_numConstraintsSatisfied > _propagatedNumConstraintsSatisfied)
 61 | 		{
 62 | 			Parent->_propagatedNumConstraintsSatisfied += _numConstraintsSatisfied;
 63 | 			Parent->_propagatedStability += Stability;
 64 | 			Parent->PropagatedDescendants.push_back(this);
 65 | 		}
 66 | 		else if (_numConstraintsSatisfied < _propagatedNumConstraintsSatisfied)
 67 | 		{
 68 | 			Parent->_propagatedNumConstraintsSatisfied += _propagatedNumConstraintsSatisfied;
 69 | 			Parent->_propagatedStability += _propagatedStability;
 70 | 			Parent->PropagatedDescendants.insert(Parent->PropagatedDescendants.end(), PropagatedDescendants.begin(), PropagatedDescendants.end());
 71 | 		}
 72 | 		else if (_numConstraintsSatisfied == _propagatedNumConstraintsSatisfied)
 73 | 		{
 74 | 			//Chose the parent over descendants if there is a tie in stability:
 75 | 			if (Stability >= _propagatedStability)
 76 | 			{
 77 | 				Parent->_propagatedNumConstraintsSatisfied += _numConstraintsSatisfied;
 78 | 				Parent->_propagatedStability += Stability;
 79 | 				Parent->PropagatedDescendants.push_back(this);
 80 | 			}
 81 | 			else
 82 | 			{
 83 | 				Parent->_propagatedNumConstraintsSatisfied += _propagatedNumConstraintsSatisfied;
 84 | 				Parent->_propagatedStability += _propagatedStability;
 85 | 				Parent->PropagatedDescendants.insert(Parent->PropagatedDescendants.end(), PropagatedDescendants.begin(), PropagatedDescendants.end());
 86 | 			}
 87 | 		}
 88 | 	}
 89 | }
 90 | void cluster::addPointsToVirtualChildCluster(std::set<int> points)
 91 | {
 92 | 	for (std::set<int>::iterator it = points.begin(); it != points.end(); ++it) {
 93 | 		_virtualChildCluster.insert(*it);
 94 | 	}
 95 | }
 96 | bool cluster::virtualChildClusterConstraintsPoint(int point)
 97 | {
 98 | 	return (_virtualChildCluster.find(point) != _virtualChildCluster.end());
 99 | }
100 | 
101 | void cluster::addVirtualChildConstraintsSatisfied(int numConstraints)
102 | {
103 | 	_propagatedNumConstraintsSatisfied += numConstraints;
104 | }
105 | 
106 | void cluster::addConstraintsSatisfied(int numConstraints)
107 | {
108 | 	_numConstraintsSatisfied += numConstraints;
109 | }
110 | 
111 | void cluster::releaseVirtualChildCluster()
112 | {
113 | 	_virtualChildCluster.clear();
114 | }
115 | 
116 | int cluster::getClusterId() {
117 | 	return this->_id;
118 | }
119 | 
120 | 
121 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/hdbscanAlgorithm.hpp:
--------------------------------------------------------------------------------
 1 | #include <limits>
 2 | #include <vector>
 3 | #include <set>
 4 | #include <map>
 5 | #include <algorithm>
 6 | #include "../Utils/bitSet.hpp"
 7 | #include <list>
 8 | #include "undirectedGraph.hpp"
 9 | #include"outlierScore.hpp"
10 | #include"cluster.hpp"
11 | #include"hdbscanConstraint.hpp"
12 | 
13 | namespace hdbscanStar
14 | {
15 | 	class hdbscanAlgorithm
16 | 	{
17 | 	public:
18 | 		/// <summary>
19 | 		/// Calculates the core distances for each point in the data set, given some value for k.
20 | 		/// </summary>
21 | 		/// <param name="distances">A vector of vectors where index [i][j] indicates the jth attribute of data point i</param>
22 | 		/// <param name="k">Each point's core distance will be it's distance to the kth nearest neighbor</param>
23 | 		/// <returns> An array of core distances</returns>
24 | 		static std::vector<double> calculateCoreDistances(std::vector<std::vector<double>> distances, int k);
25 | 		
26 | 		static undirectedGraph constructMst(std::vector<std::vector<double>> distances, std::vector<double> coreDistances, bool selfEdges);
27 | 		
28 | 	
29 | 		/// <summary>
30 | 		/// Propagates constraint satisfaction, stability, and lowest child death level from each child
31 | 		/// cluster to each parent cluster in the tree.  This method must be called before calling
32 | 		/// findProminentClusters() or calculateOutlierScores().
33 | 		/// </summary>
34 | 		/// <param name="clusters">A list of Clusters forming a cluster tree</param>
35 | 		/// <returns>true if there are any clusters with infinite stability, false otherwise</returns>
36 | 
37 | 
38 | 		static void computeHierarchyAndClusterTree(undirectedGraph *mst, int minClusterSize, std::vector<hdbscanConstraint> constraints, std::vector<std::vector<int>> &hierarchy, std::vector<double> &pointNoiseLevels, std::vector<int> &pointLastClusters, std::vector<cluster*> &clusters);
39 | 		
40 | 		static std::vector<int> findProminentClusters(std::vector<cluster*> &clusters, std::vector<std::vector<int>> &hierarchy, int numPoints);
41 | 
42 | 		static std::vector<double> findMembershipScore(std::vector<int> clusterids, std::vector<double> coreDistances);
43 | 		
44 | 		static bool propagateTree(std::vector<cluster*> &sclusters);
45 | 		
46 | 		/// <summary>
47 | 		/// Produces the outlier score for each point in the data set, and returns a sorted list of outlier
48 | 		/// scores.  propagateTree() must be called before calling this method.
49 | 		/// </summary>
50 | 		/// <param name="clusters">A list of Clusters forming a cluster tree which has already been propagated</param>
51 | 		/// <param name="pointNoiseLevels">A double[] with the levels at which each point became noise</param>
52 | 		/// <param name="pointLastClusters">An int[] with the last label each point had before becoming noise</param>
53 | 		/// <param name="coreDistances">An array of core distances for each data point</param>
54 | 		/// <returns>An List of OutlierScores, sorted in descending order</returns>
55 | 		static std::vector<outlierScore> calculateOutlierScores(
56 | 			std::vector<cluster*> &clusters,
57 | 			std::vector<double> &pointNoiseLevels,
58 | 			std::vector<int> &pointLastClusters,
59 | 			std::vector<double> coreDistances);
60 | 		
61 | 		/// <summary>
62 | 		/// Removes the set of points from their parent Cluster, and creates a new Cluster, provided the
63 | 		/// clusterId is not 0 (noise).
64 | 		/// </summary>
65 | 		/// <param name="points">The set of points to be in the new Cluster</param>
66 | 		/// <param name="clusterLabels">An array of cluster labels, which will be modified</param>
67 | 		/// <param name="parentCluster">The parent Cluster of the new Cluster being created</param>
68 | 		/// <param name="clusterLabel">The label of the new Cluster </param>
69 | 		/// <param name="edgeWeight">The edge weight at which to remove the points from their previous Cluster</param>
70 | 		/// <returns>The new Cluster, or null if the clusterId was 0</returns>
71 | 		static cluster* createNewCluster(
72 | 			std::set<int>& points,
73 | 			std::vector<int> &clusterLabels,
74 | 			cluster *parentCluster,
75 | 			int clusterLabel,
76 | 			double edgeWeight);
77 | 		
78 | 		/// <summary>
79 | 		/// Calculates the number of constraints satisfied by the new clusters and virtual children of the
80 | 		/// parents of the new clusters.
81 | 		/// </summary>
82 | 		/// <param name="newClusterLabels">Labels of new clusters</param>
83 | 		/// <param name="clusters">An List of clusters</param>
84 | 		/// <param name="constraints">An List of constraints</param>
85 | 		/// <param name="clusterLabels">An array of current cluster labels for points</param>
86 | 		static void calculateNumConstraintsSatisfied(
87 | 			std::set<int>& newClusterLabels,
88 | 			std::vector<cluster*>& clusters,
89 | 			std::vector<hdbscanConstraint>& constraints,
90 | 			std::vector<int>& clusterLabels);
91 | 		
92 | 	};
93 | 
94 | }
95 | 
96 | 
97 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # HDBSCAN-CPP
  2 | [![HDBSCAN](https://img.shields.io/badge/HDBSCAN-Clustering-yellowgreen.svg)](https://hdbscan.readthedocs.io/en/latest/how_hdbscan_works.html)
  3 | [![C++](https://img.shields.io/badge/C%2B%2B-14-green.svg )](https://en.wikipedia.org/wiki/C%2B%2B14)
  4 | [![STL](https://img.shields.io/badge/C%2B%2B-STL-brightgreen.svg )](https://en.wikipedia.org/wiki/Standard_Template_Library)
  5 | [![MIT License](https://img.shields.io/badge/License-MIT-blue.svg )](https://github.com/rohanmohapatra/hdbscan-cpp/blob/master/LICENSE.md)
  6 | [![Build Status](https://travis-ci.org/rohanmohapatra/hdbscan-cpp.svg?branch=master)](https://travis-ci.org/rohanmohapatra/hdbscan-cpp)
  7 | [![Coverage Status](https://coveralls.io/repos/github/rohanmohapatra/hdbscan-cpp/badge.svg?branch=master)](https://coveralls.io/github/rohanmohapatra/hdbscan-cpp?branch=master)
  8 | 
  9 | Fast and Efficient Implementation of HDBSCAN in C++ using STL.
 10 | --------------------------------------------------------------------------------------------------------------
 11 | 
 12 | Authored by:
 13 | * [Sumedh Basarkod](https://github.com/sumedhpb)
 14 | * [Rohan Mohapatra](https://github.com/rohanmohapatra)
 15 | 
 16 | The Standard Template Library (STL) is a set of C++ template classes to provide common programming 
 17 | data structures and functions such as lists, stacks, arrays, etc. It is a library of container classes, algorithms, and iterators. 
 18 | 
 19 | # About HDBSCAN
 20 | HDBSCAN - Hierarchical Density-Based Spatial Clustering of Applications with Noise. Performs DBSCAN over varying epsilon values and integrates the result to find a clustering that gives the best stability over epsilon. This allows HDBSCAN to find clusters of varying densities (unlike DBSCAN), and be more robust to parameter selection.
 21 | 
 22 | In practice this means that HDBSCAN returns a good clustering straight away with little or no parameter tuning -- and the primary parameter, minimum cluster size, is intuitive and easy to select.
 23 | 
 24 | HDBSCAN is ideal for exploratory data analysis; it's a fast and robust algorithm that you can trust to return meaningful clusters (if there are any).
 25 | 
 26 | Based on the paper:
 27 | > R. Campello, D. Moulavi, and J. Sander, Density-Based Clustering Based on Hierarchical Density Estimates In: Advances in Knowledge Discovery and Data Mining, Springer, pp 160-172. 2013
 28 | 
 29 | Design of the Clustering algorithm is referenced from [this](https://github.com/doxakis/HdbscanSharp).
 30 | 
 31 | ### How to Run this code?
 32 | 
 33 | Clone this project as this contains the library.
 34 | ```
 35 | git clone https://github.com/rohanmohapatra/hdbscan-cpp.git
 36 | ```
 37 | 
 38 | Run the Makefile
 39 | ```
 40 | make all clean
 41 | ```
 42 | 
 43 | Wait for it to complete, this will run the already present example in the Four Prominent Cluster Example Folder. Plot the points and see the clustering.
 44 | To run:
 45 | ```
 46 | ./main
 47 | ```
 48 | 
 49 | If you want to use it , have a look at the example and use it.
 50 | 
 51 | 
 52 | 
 53 | ### Outlier Detection
 54 | The HDBSCAN clusterer objects also support the GLOSH outlier detection algorithm. After fitting the clusterer to 
 55 | data the outlier scores can be accessed via the `outlierScores_` from the `Hdbscan` Object. The result is a vector of score values,
 56 | one for each data point that was fit. Higher scores represent more outlier like objects. Selecting outliers via upper 
 57 | quantiles is often a good approach.
 58 | 
 59 | Based on the papers:
 60 | > R.J.G.B. Campello, D. Moulavi, A. Zimek and J. Sander Hierarchical Density Estimates for Data Clustering, Visualization, and Outlier Detection, ACM Trans. on Knowledge Discovery from Data, Vol 10, 1 (July 2015), 1-51.
 61 | 
 62 | ## Examples
 63 | ```
 64 | #include<iostream>
 65 | #include"../HDBSCAN-CPP/Hdbscan/hdbscan.hpp"
 66 | using namespace std;
 67 | int main() {
 68 | 
 69 | 	Hdbscan hdbscan("HDBSCANDataset/FourProminentClusterDataset.csv");
 70 |   hdbscan.loadCsv(2);
 71 | 	hdbscan.execute(5, 5, "Euclidean");
 72 | 	hdbscan.displayResult();
 73 | 	cout << "You can access other fields like cluster labels, membership probabilities and outlier scores."<<endl;
 74 | 
 75 | 	/*Use it like this
 76 | 	hdbscan.labels_;
 77 | 	hdbscan.membershipProbabilities_;
 78 | 	hdbscan.outlierScores_;
 79 | 	*/
 80 | 	return 0;
 81 | 
 82 | }
 83 | ```
 84 | 
 85 | ### Help and Support
 86 | If you have issues, please check the issues on github. Finally, if no solution is available there feel free to open an issue ; 
 87 | the authors will attempt to respond.
 88 | 
 89 | 
 90 | ### Contributing
 91 | We welcome contributions in any form! Assistance with documentation, is always welcome. 
 92 | To contribute please fork the project make your changes and submit a pull request. 
 93 | We will do our best to work through any issues with you and get your code merged into the master branch.
 94 | 
 95 | ### Contact us if you have any questions
 96 | * Rohan Mohapatra : rohannmohapatra@gmail.com
 97 | * Sumedh Basarkod : sumedhpb8@gmail.com
 98 | 
 99 | ## Copyright and license
100 | Code released under the MIT license.
101 | 


--------------------------------------------------------------------------------
/HDBSCANDataset/FourProminentClusterDataset.csv:
--------------------------------------------------------------------------------
  1 | 0.837,2.136
  2 | -1.414,7.410
  3 | 1.155,5.100
  4 | -1.019,7.815
  5 | 1.271,1.893
  6 | 3.438,0.262
  7 | -1.808,1.597
  8 | 1.414,4.381
  9 | -0.205,8.432
 10 | -0.711,8.660
 11 | -1.712,2.778
 12 | -2.670,8.354
 13 | 1.243,4.504
 14 | -2.228,6.895
 15 | 1.455,-0.029
 16 | 0.454,3.956
 17 | 1.069,4.531
 18 | 2.569,0.507
 19 | -1.067,3.132
 20 | -1.079,2.205
 21 | 2.715,1.291
 22 | 1.777,1.187
 23 | 0.734,5.037
 24 | -1.996,2.852
 25 | -1.918,2.605
 26 | -0.556,4.696
 27 | 1.697,0.866
 28 | 0.595,4.710
 29 | -2.880,2.304
 30 | 0.187,4.027
 31 | -0.513,7.874
 32 | -2.057,7.379
 33 | 1.873,4.181
 34 | -1.131,6.767
 35 | -1.644,7.941
 36 | -2.419,7.440
 37 | -2.016,7.484
 38 | -2.621,7.986
 39 | -2.203,2.479
 40 | 1.664,0.663
 41 | 0.670,3.595
 42 | -1.985,2.055
 43 | -0.047,5.474
 44 | 1.545,4.211
 45 | -1.702,2.461
 46 | -1.022,2.768
 47 | -1.378,8.103
 48 | -1.552,2.746
 49 | -1.479,7.569
 50 | 1.989,1.510
 51 | -1.950,3.484
 52 | 2.455,0.621
 53 | -0.894,7.617
 54 | 1.697,0.755
 55 | 1.756,2.055
 56 | -1.111,2.822
 57 | -0.042,7.809
 58 | -1.141,1.976
 59 | -1.806,7.728
 60 | 1.393,0.929
 61 | -2.257,7.302
 62 | 0.572,4.323
 63 | -1.550,9.283
 64 | -1.038,2.953
 65 | -2.110,3.107
 66 | -1.187,2.784
 67 | -2.458,7.512
 68 | 2.370,0.951
 69 | -2.667,7.848
 70 | -1.497,3.214
 71 | 1.322,4.179
 72 | -0.487,3.329
 73 | -1.037,8.063
 74 | -1.605,2.974
 75 | -1.504,1.924
 76 | -0.785,8.453
 77 | -1.758,2.974
 78 | 1.190,4.728
 79 | 2.140,0.706
 80 | -1.035,8.206
 81 | 1.255,0.090
 82 | 0.596,4.086
 83 | 1.280,1.058
 84 | 1.730,1.147
 85 | -0.949,8.464
 86 | 0.935,5.332
 87 | 2.369,0.795
 88 | 0.429,4.974
 89 | -2.048,6.654
 90 | -1.457,7.487
 91 | 0.529,3.808
 92 | 1.782,0.908
 93 | -1.956,8.616
 94 | -1.746,3.012
 95 | -1.180,3.128
 96 | 1.164,3.791
 97 | 1.362,1.366
 98 | 2.601,1.088
 99 | 0.272,5.470
100 | -3.122,3.282
101 | -0.588,8.614
102 | 1.669,-0.436
103 | -0.683,7.675
104 | 2.368,0.552
105 | 1.052,4.545
106 | 2.227,1.263
107 | 2.439,-0.073
108 | 1.345,4.857
109 | -1.315,6.839
110 | 0.983,5.375
111 | -1.063,2.208
112 | -1.607,3.565
113 | 1.573,0.484
114 | -2.179,8.086
115 | 1.834,0.754
116 | 2.106,3.495
117 | -1.643,7.527
118 | 1.106,1.264
119 | 1.612,1.823
120 | 0.460,5.450
121 | -0.538,3.016
122 | 1.678,0.609
123 | -1.012,3.603
124 | 1.342,0.594
125 | 1.428,1.624
126 | 2.045,1.125
127 | 1.673,0.659
128 | -1.359,2.322
129 | 1.131,0.936
130 | -1.739,1.948
131 | -0.340,8.167
132 | -1.638,2.433
133 | -1.688,2.241
134 | 2.430,-0.064
135 | -1.380,7.185
136 | -1.252,2.339
137 | -2.395,3.398
138 | -2.092,7.481
139 | 0.488,3.268
140 | -0.539,7.456
141 | -2.592,8.076
142 | -1.047,2.965
143 | 1.256,3.382
144 | -1.622,4.272
145 | 1.869,5.441
146 | -1.764,2.222
147 | -1.382,7.288
148 | 0.008,4.176
149 | -1.103,7.302
150 | -1.794,7.581
151 | -1.512,7.944
152 | 0.959,4.561
153 | -0.601,6.300
154 | 0.225,4.770
155 | 1.567,0.018
156 | -1.034,2.921
157 | -0.922,8.099
158 | -1.886,2.248
159 | 1.869,0.956
160 | 1.101,4.890
161 | -1.932,8.306
162 | 0.670,4.041
163 | 0.744,4.122
164 | 1.640,1.819
165 | 0.815,4.785
166 | -2.633,2.631
167 | -0.961,1.274
168 | 0.214,4.885
169 | 1.435,1.307
170 | 1.214,3.648
171 | 1.083,4.063
172 | -1.226,8.296
173 | 1.482,0.690
174 | 1.896,5.185
175 | -1.324,4.131
176 | -1.150,7.893
177 | 2.469,1.679
178 | 2.311,1.304
179 | 0.573,4.088
180 | -0.968,3.122
181 | 2.625,0.950
182 | 1.684,4.196
183 | -2.221,2.731
184 | -1.578,3.034
185 | 0.082,4.567
186 | 1.433,4.377
187 | 1.063,5.176
188 | 0.768,4.398
189 | 2.470,1.315
190 | -1.732,7.164
191 | 0.347,3.452
192 | -1.001,2.849
193 | 1.016,4.485
194 | 0.560,4.214
195 | -2.118,2.035
196 | -1.362,2.383
197 | -2.784,2.992
198 | 1.652,3.656
199 | -1.940,2.189
200 | -1.815,7.978
201 | 1.202,3.644
202 | -0.969,3.267
203 | 1.870,-0.108
204 | -1.807,2.068
205 | 1.218,3.893
206 | -1.484,6.008
207 | -1.564,2.853
208 | -0.686,8.683
209 | 1.076,4.685
210 | -0.976,6.738
211 | 1.380,4.548
212 | -1.641,2.681
213 | -0.002,4.581
214 | 1.714,5.025
215 | -1.405,7.726
216 | -0.708,2.504
217 | -0.886,2.646
218 | 1.984,0.490
219 | 2.952,-0.344
220 | 0.432,4.335
221 | -1.866,7.625
222 | 2.527,0.618
223 | 2.041,0.455
224 | -2.580,3.188
225 | 1.620,0.068
226 | -2.588,3.131
227 | 0.444,3.115
228 | -0.457,7.306
229 | -1.129,7.805
230 | 2.130,5.192
231 | 1.004,4.191
232 | -1.393,8.746
233 | 0.728,3.855
234 | 0.893,1.011
235 | -1.108,2.920
236 | 0.789,4.337
237 | 1.976,0.719
238 | -1.249,3.085
239 | -1.078,8.881
240 | -1.868,3.080
241 | 2.768,1.088
242 | 0.277,4.844
243 | 3.411,0.872
244 | -1.581,7.553
245 | -1.530,7.705
246 | -1.825,7.360
247 | -1.686,7.953
248 | -1.651,3.446
249 | -1.304,3.003
250 | -0.731,6.242
251 | 2.406,4.870
252 | -1.536,3.014
253 | 1.489,0.652
254 | 0.514,4.627
255 | -1.815,3.290
256 | -1.937,3.914
257 | -0.615,3.950
258 | 2.032,0.197
259 | 2.149,1.037
260 | -1.370,7.770
261 | 0.914,4.550
262 | 0.334,4.936
263 | -2.160,3.410
264 | 1.367,0.635
265 | -0.571,8.133
266 | -1.006,3.084
267 | 1.495,3.858
268 | -0.590,7.695
269 | 0.715,5.413
270 | 2.114,1.247
271 | 1.201,0.602
272 | -2.546,3.150
273 | -1.959,2.430
274 | 2.338,3.431
275 | 3.353,1.700
276 | 1.843,0.073
277 | 1.320,1.404
278 | 2.097,4.847
279 | -1.243,8.152
280 | -1.859,7.789
281 | 2.747,1.545
282 | 2.608,1.089
283 | 1.660,3.563
284 | 2.352,0.828
285 | 2.223,0.839
286 | 3.229,1.132
287 | -1.559,7.248
288 | -0.647,3.429
289 | -1.327,8.515
290 | 0.917,3.906
291 | 2.295,-0.766
292 | 1.816,1.120
293 | -1.120,7.110
294 | -1.655,8.614
295 | -1.276,7.968
296 | 1.974,1.580
297 | 2.518,1.392
298 | 0.439,4.536
299 | 0.369,7.791
300 | -1.791,2.750
301 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Build results
 17 | [Dd]ebug/
 18 | [Dd]ebugPublic/
 19 | [Rr]elease/
 20 | [Rr]eleases/
 21 | x64/
 22 | x86/
 23 | [Aa][Rr][Mm]/
 24 | [Aa][Rr][Mm]64/
 25 | bld/
 26 | [Bb]in/
 27 | [Oo]bj/
 28 | [Ll]og/
 29 | 
 30 | # Visual Studio 2015/2017 cache/options directory
 31 | .vs/
 32 | # Uncomment if you have tasks that create the project's static files in wwwroot
 33 | #wwwroot/
 34 | 
 35 | # Visual Studio 2017 auto generated files
 36 | Generated\ Files/
 37 | 
 38 | # MSTest test Results
 39 | [Tt]est[Rr]esult*/
 40 | [Bb]uild[Ll]og.*
 41 | 
 42 | # NUNIT
 43 | *.VisualState.xml
 44 | TestResult.xml
 45 | 
 46 | # Build Results of an ATL Project
 47 | [Dd]ebugPS/
 48 | [Rr]eleasePS/
 49 | dlldata.c
 50 | 
 51 | # Benchmark Results
 52 | BenchmarkDotNet.Artifacts/
 53 | 
 54 | # .NET Core
 55 | project.lock.json
 56 | project.fragment.lock.json
 57 | artifacts/
 58 | 
 59 | # StyleCop
 60 | StyleCopReport.xml
 61 | 
 62 | # Files built by Visual Studio
 63 | *_i.c
 64 | *_p.c
 65 | *_h.h
 66 | *.ilk
 67 | *.meta
 68 | *.obj
 69 | *.iobj
 70 | *.pch
 71 | *.pdb
 72 | *.ipdb
 73 | *.pgc
 74 | *.pgd
 75 | *.rsp
 76 | *.sbr
 77 | *.tlb
 78 | *.tli
 79 | *.tlh
 80 | *.tmp
 81 | *.tmp_proj
 82 | *_wpftmp.csproj
 83 | *.log
 84 | *.vspscc
 85 | *.vssscc
 86 | .builds
 87 | *.pidb
 88 | *.svclog
 89 | *.scc
 90 | 
 91 | # Chutzpah Test files
 92 | _Chutzpah*
 93 | 
 94 | # Visual C++ cache files
 95 | ipch/
 96 | *.aps
 97 | *.ncb
 98 | *.opendb
 99 | *.opensdf
100 | *.sdf
101 | *.cachefile
102 | *.VC.db
103 | *.VC.VC.opendb
104 | 
105 | # Visual Studio profiler
106 | *.psess
107 | *.vsp
108 | *.vspx
109 | *.sap
110 | 
111 | # Visual Studio Trace Files
112 | *.e2e
113 | 
114 | # TFS 2012 Local Workspace
115 | $tf/
116 | 
117 | # Guidance Automation Toolkit
118 | *.gpState
119 | 
120 | # ReSharper is a .NET coding add-in
121 | _ReSharper*/
122 | *.[Rr]e[Ss]harper
123 | *.DotSettings.user
124 | 
125 | # JustCode is a .NET coding add-in
126 | .JustCode
127 | 
128 | # TeamCity is a build add-in
129 | _TeamCity*
130 | 
131 | # DotCover is a Code Coverage Tool
132 | *.dotCover
133 | 
134 | # AxoCover is a Code Coverage Tool
135 | .axoCover/*
136 | !.axoCover/settings.json
137 | 
138 | # Visual Studio code coverage results
139 | *.coverage
140 | *.coveragexml
141 | 
142 | # NCrunch
143 | _NCrunch_*
144 | .*crunch*.local.xml
145 | nCrunchTemp_*
146 | 
147 | # MightyMoose
148 | *.mm.*
149 | AutoTest.Net/
150 | 
151 | # Web workbench (sass)
152 | .sass-cache/
153 | 
154 | # Installshield output folder
155 | [Ee]xpress/
156 | 
157 | # DocProject is a documentation generator add-in
158 | DocProject/buildhelp/
159 | DocProject/Help/*.HxT
160 | DocProject/Help/*.HxC
161 | DocProject/Help/*.hhc
162 | DocProject/Help/*.hhk
163 | DocProject/Help/*.hhp
164 | DocProject/Help/Html2
165 | DocProject/Help/html
166 | 
167 | # Click-Once directory
168 | publish/
169 | 
170 | # Publish Web Output
171 | *.[Pp]ublish.xml
172 | *.azurePubxml
173 | # Note: Comment the next line if you want to checkin your web deploy settings,
174 | # but database connection strings (with potential passwords) will be unencrypted
175 | *.pubxml
176 | *.publishproj
177 | 
178 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
179 | # checkin your Azure Web App publish settings, but sensitive information contained
180 | # in these scripts will be unencrypted
181 | PublishScripts/
182 | 
183 | # NuGet Packages
184 | *.nupkg
185 | # The packages folder can be ignored because of Package Restore
186 | **/[Pp]ackages/*
187 | # except build/, which is used as an MSBuild target.
188 | !**/[Pp]ackages/build/
189 | # Uncomment if necessary however generally it will be regenerated when needed
190 | #!**/[Pp]ackages/repositories.config
191 | # NuGet v3's project.json files produces more ignorable files
192 | *.nuget.props
193 | *.nuget.targets
194 | 
195 | # Microsoft Azure Build Output
196 | csx/
197 | *.build.csdef
198 | 
199 | # Microsoft Azure Emulator
200 | ecf/
201 | rcf/
202 | 
203 | # Windows Store app package directories and files
204 | AppPackages/
205 | BundleArtifacts/
206 | Package.StoreAssociation.xml
207 | _pkginfo.txt
208 | *.appx
209 | 
210 | # Visual Studio cache files
211 | # files ending in .cache can be ignored
212 | *.[Cc]ache
213 | # but keep track of directories ending in .cache
214 | !?*.[Cc]ache/
215 | 
216 | # Others
217 | ClientBin/
218 | ~$*
219 | *~
220 | *.dbmdl
221 | *.dbproj.schemaview
222 | *.jfm
223 | *.pfx
224 | *.publishsettings
225 | orleans.codegen.cs
226 | 
227 | # Including strong name files can present a security risk
228 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
229 | #*.snk
230 | 
231 | # Since there are multiple workflows, uncomment next line to ignore bower_components
232 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
233 | #bower_components/
234 | 
235 | # RIA/Silverlight projects
236 | Generated_Code/
237 | 
238 | # Backup & report files from converting an old project file
239 | # to a newer Visual Studio version. Backup files are not needed,
240 | # because we have git ;-)
241 | _UpgradeReport_Files/
242 | Backup*/
243 | UpgradeLog*.XML
244 | UpgradeLog*.htm
245 | ServiceFabricBackup/
246 | *.rptproj.bak
247 | 
248 | # SQL Server files
249 | *.mdf
250 | *.ldf
251 | *.ndf
252 | 
253 | # Business Intelligence projects
254 | *.rdl.data
255 | *.bim.layout
256 | *.bim_*.settings
257 | *.rptproj.rsuser
258 | *- Backup*.rdl
259 | 
260 | # Microsoft Fakes
261 | FakesAssemblies/
262 | 
263 | # GhostDoc plugin setting file
264 | *.GhostDoc.xml
265 | 
266 | # Node.js Tools for Visual Studio
267 | .ntvs_analysis.dat
268 | node_modules/
269 | 
270 | # Visual Studio 6 build log
271 | *.plg
272 | 
273 | # Visual Studio 6 workspace options file
274 | *.opt
275 | 
276 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
277 | *.vbw
278 | 
279 | # Visual Studio LightSwitch build output
280 | **/*.HTMLClient/GeneratedArtifacts
281 | **/*.DesktopClient/GeneratedArtifacts
282 | **/*.DesktopClient/ModelManifest.xml
283 | **/*.Server/GeneratedArtifacts
284 | **/*.Server/ModelManifest.xml
285 | _Pvt_Extensions
286 | 
287 | # Paket dependency manager
288 | .paket/paket.exe
289 | paket-files/
290 | 
291 | # FAKE - F# Make
292 | .fake/
293 | 
294 | # JetBrains Rider
295 | .idea/
296 | *.sln.iml
297 | 
298 | # CodeRush personal settings
299 | .cr/personal
300 | 
301 | # Python Tools for Visual Studio (PTVS)
302 | __pycache__/
303 | *.pyc
304 | 
305 | # Cake - Uncomment if you are using it
306 | # tools/**
307 | # !tools/packages.config
308 | 
309 | # Tabs Studio
310 | *.tss
311 | 
312 | # Telerik's JustMock configuration file
313 | *.jmconfig
314 | 
315 | # BizTalk build output
316 | *.btp.cs
317 | *.btm.cs
318 | *.odx.cs
319 | *.xsd.cs
320 | 
321 | # OpenCover UI analysis results
322 | OpenCover/
323 | 
324 | # Azure Stream Analytics local run output
325 | ASALocalRun/
326 | 
327 | # MSBuild Binary and Structured Log
328 | *.binlog
329 | 
330 | # NVidia Nsight GPU debugger configuration file
331 | *.nvuser
332 | 
333 | # MFractors (Xamarin productivity tool) working folder
334 | .mfractor/
335 | 
336 | # Local History for Visual Studio
337 | .localhistory/
338 | 
339 | # BeatPulse healthcheck temp database
340 | healthchecksdb
341 | 


--------------------------------------------------------------------------------
/HDBSCAN-CPP/HdbscanStar/hdbscanAlgorithm.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <limits>
  3 | #include <vector>
  4 | #include <set>
  5 | #include <map>
  6 | #include <algorithm>
  7 | #include "../Utils/bitSet.hpp"
  8 | #include <list>
  9 | #include "undirectedGraph.hpp"
 10 | #include"outlierScore.hpp"
 11 | #include"cluster.hpp"
 12 | #include"hdbscanConstraint.hpp"
 13 | #include"hdbscanAlgorithm.hpp"
 14 | 
 15 | 
 16 | std::vector<double> hdbscanStar::hdbscanAlgorithm::calculateCoreDistances(std::vector<std::vector<double>> distances, int k)
 17 | {
 18 | 	int length = distances.size();
 19 | 
 20 | 	int numNeighbors = k - 1;
 21 | 	std::vector<double>coreDistances(length);
 22 | 	if (k == 1)
 23 | 	{
 24 | 		for (int point = 0; point < length; point++)
 25 | 		{
 26 | 			coreDistances[point] = 0;
 27 | 		}
 28 | 		return coreDistances;
 29 | 	}
 30 | 	for (int point = 0; point < length; point++)
 31 | 	{
 32 | 		std::vector<double> kNNDistances(numNeighbors);  //Sorted nearest distances found so far
 33 | 		for (int i = 0; i < numNeighbors; i++)
 34 | 		{
 35 | 			kNNDistances[i] = std::numeric_limits<double>::max();
 36 | 		}
 37 | 
 38 | 		for (int neighbor = 0; neighbor < length; neighbor++)
 39 | 		{
 40 | 			if (point == neighbor)
 41 | 				continue;
 42 | 			double distance = distances[point][neighbor];
 43 | 			int neighborIndex = numNeighbors;
 44 | 			//Check at which position in the nearest distances the current distance would fit:
 45 | 			while (neighborIndex >= 1 && distance < kNNDistances[neighborIndex - 1])
 46 | 			{
 47 | 				neighborIndex--;
 48 | 			}
 49 | 			//Shift elements in the array to make room for the current distance:
 50 | 			if (neighborIndex < numNeighbors)
 51 | 			{
 52 | 				for (int shiftIndex = numNeighbors - 1; shiftIndex > neighborIndex; shiftIndex--)
 53 | 				{
 54 | 					kNNDistances[shiftIndex] = kNNDistances[shiftIndex - 1];
 55 | 				}
 56 | 				kNNDistances[neighborIndex] = distance;
 57 | 			}
 58 | 
 59 | 		}
 60 | 		coreDistances[point] = kNNDistances[numNeighbors - 1];
 61 | 	}
 62 | 	return coreDistances;
 63 | }
 64 | undirectedGraph hdbscanStar::hdbscanAlgorithm::constructMst(std::vector<std::vector<double>> distances, std::vector<double> coreDistances, bool selfEdges)
 65 | {
 66 | 	int length = distances.size();
 67 | 	int selfEdgeCapacity = 0;
 68 | 	if (selfEdges)
 69 | 		selfEdgeCapacity = length;
 70 | 	bitSet attachedPoints;
 71 | 
 72 | 	std::vector<int> nearestMRDNeighbors(length - 1 + selfEdgeCapacity);
 73 | 	std::vector<double> nearestMRDDistances(length - 1 + selfEdgeCapacity);
 74 | 
 75 | 	for (int i = 0; i < length - 1; i++)
 76 | 	{
 77 | 		nearestMRDDistances[i] = std::numeric_limits<double>::max();
 78 | 	}
 79 | 
 80 | 	int currentPoint = length - 1;
 81 | 	int numAttachedPoints = 1;
 82 | 	attachedPoints.set(length - 1);
 83 | 
 84 | 	while (numAttachedPoints < length)
 85 | 	{
 86 | 
 87 | 		int nearestMRDPoint = -1;
 88 | 		double nearestMRDDistance = std::numeric_limits<double>::max();
 89 | 		for (int neighbor = 0; neighbor < length; neighbor++)
 90 | 		{
 91 | 			if (currentPoint == neighbor)
 92 | 				continue;
 93 | 			if (attachedPoints.get(neighbor) == true)
 94 | 				continue;
 95 | 			double distance = distances[currentPoint][neighbor];
 96 | 			double mutualReachabiltiyDistance = distance;
 97 | 			if (coreDistances[currentPoint] > mutualReachabiltiyDistance)
 98 | 				mutualReachabiltiyDistance = coreDistances[currentPoint];
 99 | 
100 | 			if (coreDistances[neighbor] > mutualReachabiltiyDistance)
101 | 				mutualReachabiltiyDistance = coreDistances[neighbor];
102 | 
103 | 			if (mutualReachabiltiyDistance < nearestMRDDistances[neighbor])
104 | 			{
105 | 				nearestMRDDistances[neighbor] = mutualReachabiltiyDistance;
106 | 				nearestMRDNeighbors[neighbor] = currentPoint;
107 | 			}
108 | 
109 | 			if (nearestMRDDistances[neighbor] <= nearestMRDDistance)
110 | 			{
111 | 				nearestMRDDistance = nearestMRDDistances[neighbor];
112 | 				nearestMRDPoint = neighbor;
113 | 			}
114 | 
115 | 		}
116 | 		attachedPoints.set(nearestMRDPoint);
117 | 		numAttachedPoints++;
118 | 		currentPoint = nearestMRDPoint;
119 | 	}
120 | 	std::vector<int> otherVertexIndices(length - 1 + selfEdgeCapacity);
121 | 	for (int i = 0; i < length - 1; i++)
122 | 	{
123 | 		otherVertexIndices[i] = i;
124 | 	}
125 | 	if (selfEdges)
126 | 	{
127 | 		for (int i = length - 1; i < length * 2 - 1; i++)
128 | 		{
129 | 			int vertex = i - (length - 1);
130 | 			nearestMRDNeighbors[i] = vertex;
131 | 			otherVertexIndices[i] = vertex;
132 | 			nearestMRDDistances[i] = coreDistances[vertex];
133 | 		}
134 | 	}
135 | 	undirectedGraph undirectedGraphObject(length, nearestMRDNeighbors, otherVertexIndices, nearestMRDDistances);
136 | 	return undirectedGraphObject;
137 | 
138 | }
139 | 
140 | void hdbscanStar::hdbscanAlgorithm::computeHierarchyAndClusterTree(undirectedGraph* mst, int minClusterSize, std::vector<hdbscanConstraint> constraints, std::vector<std::vector<int>>& hierarchy, std::vector<double>& pointNoiseLevels, std::vector<int>& pointLastClusters, std::vector<cluster*>& clusters)
141 | {
142 | 	int hierarchyPosition = 0;
143 | 
144 | 	//The current edge being removed from the MST:
145 | 	int currentEdgeIndex = mst->getNumEdges() - 1;
146 | 	int nextClusterLabel = 2;
147 | 	bool nextLevelSignificant = true;
148 | 
149 | 	//The previous and current cluster numbers of each point in the data set:
150 | 	std::vector<int> previousClusterLabels(mst->getNumVertices());
151 | 	std::vector<int> currentClusterLabels(mst->getNumVertices());
152 | 
153 | 	for (int i = 0; i < currentClusterLabels.size(); i++)
154 | 	{
155 | 		currentClusterLabels[i] = 1;
156 | 		previousClusterLabels[i] = 1;
157 | 	}
158 | 	//std::vector<cluster *> clusters;
159 | 	clusters.push_back(NULL);
160 | 	//cluster cluster_object(1, NULL, std::numeric_limits<double>::quiet_NaN(),  mst->getNumVertices());
161 | 	clusters.push_back(new cluster(1, NULL, std::numeric_limits<double>::quiet_NaN(), mst->getNumVertices()));
162 | 
163 | 	std::set<int> clusterOne;
164 | 	clusterOne.insert(1);
165 | 	calculateNumConstraintsSatisfied(
166 | 		clusterOne,
167 | 		clusters,
168 | 		constraints,
169 | 		currentClusterLabels);
170 | 	std::set<int> affectedClusterLabels;
171 | 	std::set<int> affectedVertices;
172 | 	while (currentEdgeIndex >= 0)
173 | 	{
174 | 		double currentEdgeWeight = mst->getEdgeWeightAtIndex(currentEdgeIndex);
175 | 		std::vector<cluster*> newClusters;
176 | 		while (currentEdgeIndex >= 0 && mst->getEdgeWeightAtIndex(currentEdgeIndex) == currentEdgeWeight)
177 | 		{
178 | 			int firstVertex = mst->getFirstVertexAtIndex(currentEdgeIndex);
179 | 			int secondVertex = mst->getSecondVertexAtIndex(currentEdgeIndex);
180 | 			std::vector<int>& firstVertexEdgeList = mst->getEdgeListForVertex(firstVertex);
181 | 			std::vector<int>::iterator secondVertexInFirstEdgeList = std::find(firstVertexEdgeList.begin(), firstVertexEdgeList.end(), secondVertex);
182 | 			if (secondVertexInFirstEdgeList != mst->getEdgeListForVertex(firstVertex).end())
183 | 				mst->getEdgeListForVertex(firstVertex).erase(secondVertexInFirstEdgeList);
184 | 			std::vector<int>& secondVertexEdgeList = mst->getEdgeListForVertex(secondVertex);
185 | 			std::vector<int>::iterator firstVertexInSecondEdgeList = std::find(secondVertexEdgeList.begin(), secondVertexEdgeList.end(), firstVertex);
186 | 			if (firstVertexInSecondEdgeList != mst->getEdgeListForVertex(secondVertex).end())
187 | 				mst->getEdgeListForVertex(secondVertex).erase(firstVertexInSecondEdgeList);
188 | 
189 | 			if (currentClusterLabels[firstVertex] == 0)
190 | 			{
191 | 				currentEdgeIndex--;
192 | 				continue;
193 | 			}
194 | 			affectedVertices.insert(firstVertex);
195 | 			affectedVertices.insert(secondVertex);
196 | 			affectedClusterLabels.insert(currentClusterLabels[firstVertex]);
197 | 			currentEdgeIndex--;
198 | 		}
199 | 		if (!affectedClusterLabels.size())
200 | 			continue;
201 | 		while (affectedClusterLabels.size())
202 | 		{
203 | 			int examinedClusterLabel = *prev(affectedClusterLabels.end());
204 | 			affectedClusterLabels.erase(prev(affectedClusterLabels.end()));
205 | 			std::set<int> examinedVertices;
206 | 			//std::set<int>::iterator affectedIt;
207 | 			for (auto affectedIt = affectedVertices.begin(); affectedIt != affectedVertices.end();)
208 | 			{
209 | 				int vertex = *affectedIt;
210 | 				if (currentClusterLabels[vertex] == examinedClusterLabel)
211 | 				{
212 | 					examinedVertices.insert(vertex);
213 | 					affectedIt = affectedVertices.erase(affectedIt);
214 | 
215 | 				}
216 | 				else {
217 | 					++affectedIt;
218 | 				}
219 | 			}
220 | 			std::set<int> firstChildCluster;
221 | 			std::list<int> unexploredFirstChildClusterPoints;
222 | 			int numChildClusters = 0;
223 | 			while (examinedVertices.size())
224 | 			{
225 | 
226 | 				std::set<int> constructingSubCluster;
227 | 				int iters = 0;
228 | 				std::list<int> unexploredSubClusterPoints;
229 | 				bool anyEdges = false;
230 | 				bool incrementedChildCount = false;
231 | 				int rootVertex = *prev(examinedVertices.end());
232 | 				constructingSubCluster.insert(rootVertex);
233 | 				unexploredSubClusterPoints.push_back(rootVertex);
234 | 				examinedVertices.erase(prev(examinedVertices.end()));
235 | 				while (unexploredSubClusterPoints.size())
236 | 				{
237 | 					int vertexToExplore = *unexploredSubClusterPoints.begin();
238 | 					unexploredSubClusterPoints.erase(unexploredSubClusterPoints.begin());
239 | 					std::vector<int>& vertexToExploreEdgeList = mst->getEdgeListForVertex(vertexToExplore);
240 | 					for (std::vector<int>::iterator it = vertexToExploreEdgeList.begin(); it != vertexToExploreEdgeList.end();)
241 | 					{
242 | 						int neighbor = *it;
243 | 						anyEdges = true;
244 | 						if (std::find(constructingSubCluster.begin(), constructingSubCluster.end(), neighbor) == constructingSubCluster.end())
245 | 						{
246 | 							constructingSubCluster.insert(neighbor);
247 | 							unexploredSubClusterPoints.push_back(neighbor);
248 | 							if (std::find(examinedVertices.begin(), examinedVertices.end(), neighbor) != examinedVertices.end())
249 | 								examinedVertices.erase(std::find(examinedVertices.begin(), examinedVertices.end(), neighbor));
250 | 
251 | 						}
252 | 						else {
253 | 							++it;
254 | 						}
255 | 					}
256 | 					if (!incrementedChildCount && constructingSubCluster.size() >= minClusterSize && anyEdges)
257 | 					{
258 | 						incrementedChildCount = true;
259 | 						numChildClusters++;
260 | 
261 | 						//If this is the first valid child cluster, stop exploring it:
262 | 						if (firstChildCluster.size() == 0)
263 | 						{
264 | 							firstChildCluster = constructingSubCluster;
265 | 							unexploredFirstChildClusterPoints = unexploredSubClusterPoints;
266 | 							break;
267 | 						}
268 | 					}
269 | 
270 | 				}
271 | 				//If there could be a split, and this child cluster is valid:
272 | 				if (numChildClusters >= 2 && constructingSubCluster.size() >= minClusterSize && anyEdges)
273 | 				{
274 | 					//Check this child cluster is not equal to the unexplored first child cluster:
275 | 					int firstChildClusterMember = *prev(firstChildCluster.end());
276 | 					if (std::find(constructingSubCluster.begin(), constructingSubCluster.end(), firstChildClusterMember) != constructingSubCluster.end())
277 | 						numChildClusters--;
278 | 					//Otherwise, c a new cluster:
279 | 					else
280 | 					{
281 | 						cluster* newCluster = createNewCluster(constructingSubCluster, currentClusterLabels,
282 | 							clusters[examinedClusterLabel], nextClusterLabel, currentEdgeWeight);
283 | 						newClusters.push_back(newCluster);
284 | 						clusters.push_back(newCluster);
285 | 						nextClusterLabel++;
286 | 					}
287 | 				}
288 | 				else if (constructingSubCluster.size() < minClusterSize || !anyEdges)
289 | 				{
290 | 					createNewCluster(constructingSubCluster, currentClusterLabels,
291 | 						clusters[examinedClusterLabel], 0, currentEdgeWeight);
292 | 
293 | 					for (std::set<int>::iterator it = constructingSubCluster.begin(); it != constructingSubCluster.end(); it++)
294 | 					{
295 | 						int point = *it;
296 | 						pointNoiseLevels[point] = currentEdgeWeight;
297 | 						pointLastClusters[point] = examinedClusterLabel;
298 | 					}
299 | 				}
300 | 			}
301 | 			if (numChildClusters >= 2 && currentClusterLabels[*firstChildCluster.begin()] == examinedClusterLabel)
302 | 			{
303 | 				while (unexploredFirstChildClusterPoints.size())
304 | 				{
305 | 					int vertexToExplore = *unexploredFirstChildClusterPoints.begin();
306 | 					unexploredFirstChildClusterPoints.pop_front();
307 | 					for (std::vector<int>::iterator it = mst->getEdgeListForVertex(vertexToExplore).begin(); it != mst->getEdgeListForVertex(vertexToExplore).end(); it++)
308 | 					{
309 | 						int neighbor = *it;
310 | 						if (std::find(firstChildCluster.begin(), firstChildCluster.end(), neighbor) == firstChildCluster.end())
311 | 						{
312 | 							firstChildCluster.insert(neighbor);
313 | 							unexploredFirstChildClusterPoints.push_back(neighbor);
314 | 						}
315 | 					}
316 | 				}
317 | 				cluster* newCluster = createNewCluster(firstChildCluster, currentClusterLabels,
318 | 					clusters[examinedClusterLabel], nextClusterLabel, currentEdgeWeight);
319 | 				newClusters.push_back(newCluster);
320 | 				clusters.push_back(newCluster);
321 | 				nextClusterLabel++;
322 | 			}
323 | 		}
324 | 		if (nextLevelSignificant || newClusters.size())
325 | 		{
326 | 			std::vector<int> lineContents(previousClusterLabels.size());
327 | 			for (int i = 0; i < previousClusterLabels.size(); i++)
328 | 				lineContents[i] = previousClusterLabels[i];
329 | 			hierarchy.push_back(lineContents);
330 | 			hierarchyPosition++;
331 | 		}
332 | 		std::set<int> newClusterLabels;
333 | 		for (std::vector<cluster*>::iterator it = newClusters.begin(); it != newClusters.end(); it++)
334 | 		{
335 | 			cluster* newCluster = *it;
336 | 			newCluster->HierarchyPosition = hierarchyPosition;
337 | 			newClusterLabels.insert(newCluster->Label);
338 | 		}
339 | 		if (newClusterLabels.size())
340 | 			calculateNumConstraintsSatisfied(newClusterLabels, clusters, constraints, currentClusterLabels);
341 | 
342 | 		for (int i = 0; i < previousClusterLabels.size(); i++)
343 | 		{
344 | 			previousClusterLabels[i] = currentClusterLabels[i];
345 | 		}
346 | 		if (!newClusters.size())
347 | 			nextLevelSignificant = false;
348 | 		else
349 | 			nextLevelSignificant = true;
350 | 	}
351 | 
352 | 	{
353 | 		std::vector<int> lineContents(previousClusterLabels.size() + 1);
354 | 		for (int i = 0; i < previousClusterLabels.size(); i++)
355 | 			lineContents[i] = 0;
356 | 		hierarchy.push_back(lineContents);
357 | 	}
358 | }
359 | std::vector<int> hdbscanStar::hdbscanAlgorithm::findProminentClusters(std::vector<cluster*>& clusters, std::vector<std::vector<int>>& hierarchy, int numPoints)
360 | {
361 | 	//Take the list of propagated clusters from the root cluster:
362 | 	std::vector<cluster*> solution = clusters[1]->PropagatedDescendants;
363 | 	std::vector<int> flatPartitioning(numPoints);
364 | 
365 | 	//Store all the hierarchy positions at which to find the birth points for the flat clustering:
366 | 	std::map<int, std::vector<int>> significantHierarchyPositions;
367 | 
368 | 	std::vector<cluster*>::iterator it = solution.begin();
369 | 	while (it != solution.end())
370 | 	{
371 | 		int hierarchyPosition = (*it)->HierarchyPosition;
372 | 		if (significantHierarchyPositions.count(hierarchyPosition) > 0)
373 | 			significantHierarchyPositions[hierarchyPosition].push_back((*it)->Label);
374 | 		else
375 | 			significantHierarchyPositions[hierarchyPosition].push_back((*it)->Label);
376 | 		it++;
377 | 	}
378 | 
379 | 	//Go through the hierarchy file, setting labels for the flat clustering:
380 | 	while (significantHierarchyPositions.size())
381 | 	{
382 | 		std::map<int, std::vector<int>>::iterator entry = significantHierarchyPositions.begin();
383 | 		std::vector<int> clusterList = entry->second;
384 | 		int hierarchyPosition = entry->first;
385 | 		significantHierarchyPositions.erase(entry->first);
386 | 
387 | 		std::vector<int> lineContents = hierarchy[hierarchyPosition];
388 | 
389 | 		for (int i = 0; i < lineContents.size(); i++)
390 | 		{
391 | 			int label = lineContents[i];
392 | 			if (std::find(clusterList.begin(), clusterList.end(), label) != clusterList.end())
393 | 				flatPartitioning[i] = label;
394 | 		}
395 | 	}
396 | 	return flatPartitioning;
397 | }
398 | std::vector<double> hdbscanStar::hdbscanAlgorithm::findMembershipScore(std::vector<int> clusterids, std::vector<double> coreDistances)
399 | {
400 | 	
401 | 	int length = clusterids.size();
402 | 	std::vector<double> prob(length, std::numeric_limits<double>::max());
403 | 	int i=0;
404 | 	
405 | 	while(i<length)
406 | 	{
407 | 		if(prob[i]==std::numeric_limits<double>::max())
408 | 		{
409 | 			
410 | 			int clusterno = clusterids[i];
411 | 			std::vector<int>::iterator iter = clusterids.begin()+i;
412 | 			std::vector<int> indices;
413 | 			while ((iter = std::find(iter, clusterids.end(), clusterno)) != clusterids.end())
414 | 			{
415 | 				
416 | 				indices.push_back(distance(clusterids.begin(), iter));
417 | 				iter++;
418 | 				if(iter==clusterids.end())
419 | 					break;
420 | 
421 | 			}
422 | 			if(clusterno==0)
423 | 			{
424 | 				for(int j=0; j<indices.size();j++)
425 | 				{
426 | 					prob[indices[j]] = 0;
427 | 				}
428 | 				i++;
429 | 				continue;
430 | 			}
431 | 			std::vector<double> tempCoreDistances(indices.size());
432 | 			for(int j=0; j<indices.size();j++)
433 | 			{
434 | 				tempCoreDistances[j] = coreDistances[j];
435 | 			}
436 | 			double maxCoreDistance = *max_element(tempCoreDistances.begin(), tempCoreDistances.end());
437 | 			for(int j=0; j<tempCoreDistances.size();j++)
438 | 			{
439 | 				prob[indices[j]] = ( maxCoreDistance - tempCoreDistances[j] ) / maxCoreDistance;
440 | 			}
441 | 
442 | 		}
443 | 		
444 | 		i++;
445 | 	}
446 | 	return prob;
447 | 	
448 | }
449 | 
450 | bool hdbscanStar::hdbscanAlgorithm::propagateTree(std::vector<cluster*>& clusters)
451 | {
452 | 	std::map<int, cluster*> clustersToExamine;
453 | 	bitSet addedToExaminationList;
454 | 	bool infiniteStability = false;
455 | 
456 | 	//Find all leaf clusters in the cluster tree:
457 | 	for (cluster* cluster : clusters)
458 | 	{
459 | 		if (cluster != NULL && !cluster->HasChildren)
460 | 		{
461 | 			int label = cluster->Label;
462 | 			clustersToExamine.erase(label);
463 | 			clustersToExamine.insert({ label, cluster });
464 | 			addedToExaminationList.set(label);
465 | 		}
466 | 	}
467 | 	//Iterate through every cluster, propagating stability from children to parents:
468 | 	while (clustersToExamine.size())
469 | 	{
470 | 		std::map<int, cluster*>::iterator currentKeyValue = prev(clustersToExamine.end());
471 | 		cluster* currentCluster = currentKeyValue->second;
472 | 		clustersToExamine.erase(currentKeyValue->first);
473 | 		currentCluster->propagate();
474 | 
475 | 		if (currentCluster->Stability == std::numeric_limits<double>::infinity())
476 | 			infiniteStability = true;
477 | 
478 | 		if (currentCluster->Parent != NULL)
479 | 		{
480 | 			cluster* parent = currentCluster->Parent;
481 | 			int label = parent->Label;
482 | 
483 | 			if (!addedToExaminationList.get(label))
484 | 			{
485 | 				clustersToExamine.erase(label);
486 | 				clustersToExamine.insert({ label, parent });
487 | 				addedToExaminationList.set(label);
488 | 			}
489 | 		}
490 | 	}
491 | 
492 | 	return infiniteStability;
493 | }
494 | 
495 | /// <summary>
496 | /// Produces the outlier score for each point in the data set, and returns a sorted list of outlier
497 | /// scores.  propagateTree() must be called before calling this method.
498 | /// </summary>
499 | /// <param name="clusters">A list of Clusters forming a cluster tree which has already been propagated</param>
500 | /// <param name="pointNoiseLevels">A double[] with the levels at which each point became noise</param>
501 | /// <param name="pointLastClusters">An int[] with the last label each point had before becoming noise</param>
502 | /// <param name="coreDistances">An array of core distances for each data point</param>
503 | /// <returns>An List of OutlierScores, sorted in descending order</returns>
504 | std::vector<outlierScore> hdbscanStar::hdbscanAlgorithm::calculateOutlierScores(
505 | 	std::vector<cluster*>& clusters,
506 | 	std::vector<double>& pointNoiseLevels,
507 | 	std::vector<int>& pointLastClusters,
508 | 	std::vector<double> coreDistances)
509 | {
510 | 	int numPoints = pointNoiseLevels.size();
511 | 	std::vector<outlierScore> outlierScores;
512 | 
513 | 	//Iterate through each point, calculating its outlier score:
514 | 	for (int i = 0; i < numPoints; i++)
515 | 	{
516 | 		double epsilonMax = clusters[pointLastClusters[i]]->PropagatedLowestChildDeathLevel;
517 | 		double epsilon = pointNoiseLevels[i];
518 | 		double score = 0;
519 | 
520 | 		if (epsilon != 0)
521 | 			score = 1 - (epsilonMax / epsilon);
522 | 
523 | 		outlierScores.push_back(outlierScore(score, coreDistances[i], i));
524 | 	}
525 | 	//Sort the outlier scores:
526 | 	sort(outlierScores.begin(), outlierScores.end());
527 | 
528 | 	return outlierScores;
529 | }
530 | 
531 | /// <summary>
532 | /// Removes the set of points from their parent Cluster, and creates a new Cluster, provided the
533 | /// clusterId is not 0 (noise).
534 | /// </summary>
535 | /// <param name="points">The set of points to be in the new Cluster</param>
536 | /// <param name="clusterLabels">An array of cluster labels, which will be modified</param>
537 | /// <param name="parentCluster">The parent Cluster of the new Cluster being created</param>
538 | /// <param name="clusterLabel">The label of the new Cluster </param>
539 | /// <param name="edgeWeight">The edge weight at which to remove the points from their previous Cluster</param>
540 | /// <returns>The new Cluster, or null if the clusterId was 0</returns>
541 | cluster* hdbscanStar::hdbscanAlgorithm::createNewCluster(
542 | 	std::set<int>& points,
543 | 	std::vector<int>& clusterLabels,
544 | 	cluster* parentCluster,
545 | 	int clusterLabel,
546 | 	double edgeWeight)
547 | {
548 | 	std::set<int>::iterator it = points.begin();
549 | 	while (it != points.end())
550 | 	{
551 | 		clusterLabels[*it] = clusterLabel;
552 | 		++it;
553 | 	}
554 | 	parentCluster->detachPoints(points.size(), edgeWeight);
555 | 
556 | 	if (clusterLabel != 0)
557 | 	{
558 | 		return new cluster(clusterLabel, parentCluster, edgeWeight, points.size());
559 | 	}
560 | 
561 | 	parentCluster->addPointsToVirtualChildCluster(points);
562 | 	return NULL;
563 | }
564 | /// <summary>
565 | /// Calculates the number of constraints satisfied by the new clusters and virtual children of the
566 | /// parents of the new clusters.
567 | /// </summary>
568 | /// <param name="newClusterLabels">Labels of new clusters</param>
569 | /// <param name="clusters">An List of clusters</param>
570 | /// <param name="constraints">An List of constraints</param>
571 | /// <param name="clusterLabels">An array of current cluster labels for points</param>
572 | void hdbscanStar::hdbscanAlgorithm::calculateNumConstraintsSatisfied(
573 | 	std::set<int>& newClusterLabels,
574 | 	std::vector<cluster*>& clusters,
575 | 	std::vector<hdbscanConstraint>& constraints,
576 | 	std::vector<int>& clusterLabels)
577 | {
578 | 
579 | 	if (constraints.size() == 0)
580 | 		return;
581 | 
582 | 	std::vector<cluster> parents;
583 | 	std::vector<cluster> ::iterator it;
584 | 	for (int label : newClusterLabels)
585 | 	{
586 | 		cluster* parent = clusters[label]->Parent;
587 | 		if (parent != NULL && !(find(parents.begin(), parents.end(), *parent) != parents.end()))
588 | 			parents.push_back(*parent);
589 | 	}
590 | 
591 | 	for (hdbscanConstraint constraint : constraints)
592 | 	{
593 | 		int labelA = clusterLabels[constraint.getPointA()];
594 | 		int labelB = clusterLabels[constraint.getPointB()];
595 | 
596 | 		if (constraint.getConstraintType() == hdbscanConstraintType::mustLink && labelA == labelB)
597 | 		{
598 | 			if (find(newClusterLabels.begin(), newClusterLabels.end(), labelA) != newClusterLabels.end())
599 | 				clusters[labelA]->addConstraintsSatisfied(2);
600 | 		}
601 | 		else if (constraint.getConstraintType() == hdbscanConstraintType::cannotLink && (labelA != labelB || labelA == 0))
602 | 		{
603 | 			if (labelA != 0 && find(newClusterLabels.begin(), newClusterLabels.end(), labelA) != newClusterLabels.end())
604 | 				clusters[labelA]->addConstraintsSatisfied(1);
605 | 			if (labelB != 0 && (find(newClusterLabels.begin(), newClusterLabels.end(), labelA) != newClusterLabels.end()))
606 | 				clusters[labelB]->addConstraintsSatisfied(1);
607 | 			if (labelA == 0)
608 | 			{
609 | 				for (cluster parent : parents)
610 | 				{
611 | 					if (parent.virtualChildClusterConstraintsPoint(constraint.getPointA()))
612 | 					{
613 | 						parent.addVirtualChildConstraintsSatisfied(1);
614 | 						break;
615 | 					}
616 | 				}
617 | 			}
618 | 			if (labelB == 0)
619 | 			{
620 | 				for (cluster parent : parents)
621 | 				{
622 | 					if (parent.virtualChildClusterConstraintsPoint(constraint.getPointB()))
623 | 					{
624 | 						parent.addVirtualChildConstraintsSatisfied(1);
625 | 						break;
626 | 					}
627 | 				}
628 | 			}
629 | 		}
630 | 	}
631 | 
632 | 	for (cluster parent : parents)
633 | 	{
634 | 		parent.releaseVirtualChildCluster();
635 | 	}
636 | }
637 | 


--------------------------------------------------------------------------------