Added shared ptr constructors for some classes.

Author: armytrong

CechComplex.cpp

@@ -8,6 +8,7 @@
 #include <ranges>
 #include <generator>
 #include <bits/ranges_algo.h>
+#include "DataCover.h"
 
 namespace MapperLib {
 
@@ -52,7 +53,6 @@ std::vector<Simplex> CechComplex::generate_k_simplices(std::vector<MapperCluster
             assert(subset_indexset.size() == k);
             if(not std::ranges::is_sorted(subset_indexset)) { continue; }
             subset_indexset.push_back(relevant_clusters.size()-1);
-            std::cout << "subset: " << subset_indexset << std::endl;
             if(check_cluster_intersection(relevant_clusters, subset_indexset)) {
                 std::vector<ClusterId> id_vector;
                 for(auto const subset_index : subset_indexset) {
@@ -113,6 +113,9 @@ std::vector<size_t> CechComplex::get_vector_intersection(std::vector<size_t> vec
 CechComplexFactory::CechComplexFactory(Dimension const max_dimension): _max_dimension(max_dimension)
 {}
 
+std::shared_ptr<ComplexFactory> CechComplexFactory::make_shared(Dimension max_dimension)
+{return std::make_shared<CechComplexFactory>(max_dimension);}
+
 CechComplex::CechComplex(const DataCover &data_cover, Dimension const max_dimension): _data_cover(data_cover),
                                                                                 _max_dimension(max_dimension) {
 

CechComplex.h

@@ -7,10 +7,12 @@
 
 #include <vector>
 #include <generator>
+#include <memory>
+
 #include "typedefs.h"
-#include "Mapper.h"
 
 namespace MapperLib {
+class DataCover;
 
 class Complex {
 public:
@@ -48,6 +50,8 @@ class CechComplexFactory final : public ComplexFactory
 {
 public:
     explicit CechComplexFactory(Dimension max_dimension);
+    [[nodiscard]] static std::shared_ptr<ComplexFactory> make_shared(Dimension max_dimension);
+
     [[nodiscard]] std::unique_ptr<Complex> create_complex(DataCover const &data_cover) const override;
 
 private:

DataCover.cpp

@@ -212,6 +212,12 @@ MapperLib::DataCoverFactory::DataCoverFactory(
 {
 }
 
+std::shared_ptr<MapperLib::DataCoverFactory> MapperLib::DataCoverFactory::make_shared(size_t resolution,
+    double perc_overlap, std::optional<Vector> minima, std::optional<Vector> maxima)
+{
+    return std::make_shared<DataCoverFactory>(resolution, perc_overlap, minima, maxima);
+}
+
 std::unique_ptr<MapperLib::DataCover> MapperLib::DataCoverFactory::create_data_cover(Matrix const &data) const
 {
     return std::make_unique<DataCover>(_resolution, _perc_overlap, data, _minima, _maxima);

DataCover.h

@@ -66,6 +66,8 @@ class DataCoverFactory
 {
 public:
     DataCoverFactory(size_t resolution, double perc_overlap, std::optional<Vector> minima = std::nullopt, std::optional<Vector> maxima = std::nullopt);
+    [[nodiscard]] static std::shared_ptr<DataCoverFactory> make_shared(size_t resolution, double perc_overlap, std::optional<Vector> minima = std::nullopt, std::optional<Vector> maxima = std::nullopt);
+
     [[nodiscard]] std::unique_ptr<DataCover> create_data_cover(Matrix const& data) const;
 
 private:

Projection.cpp

@@ -8,6 +8,11 @@ namespace MapperLib {
 CoordinatePlaneProjection::CoordinatePlaneProjection(std::vector<Dimension> dimensions) : _dimensions(std::move
 (dimensions)){}
 
+std::shared_ptr<Projection> CoordinatePlaneProjection::make_shared(std::vector<Dimension> dimensions)
+{
+    return std::make_shared<CoordinatePlaneProjection>(std::move(dimensions));
+}
+
 Matrix CoordinatePlaneProjection::project(const Matrix &data) const {
     Matrix result;
     result.reserve(data.size());

Projection.h

@@ -4,6 +4,8 @@
 
 #ifndef MAPPER_PROJECTION_H
 #define MAPPER_PROJECTION_H
+#include <memory>
+
 #include "typedefs.h"
 
 namespace MapperLib{
@@ -17,6 +19,8 @@ class Projection {
 class CoordinatePlaneProjection final : public  Projection{
 public:
     explicit CoordinatePlaneProjection(std::vector<Dimension> dimensions);
+    [[nodiscard]] static std::shared_ptr<Projection> make_shared(std::vector<Dimension> dimensions);
+
     [[nodiscard]] Matrix project (Matrix const& data) const override;
 private:
     std::vector<Dimension> _dimensions;

SingleLinkage.cpp

@@ -16,6 +16,10 @@ SingleLinkage::SingleLinkage(std::optional<int> const num_clusters, std::optiona
     _distance_threshold = distance_threshold;
 }
 
+std::shared_ptr<Clusterer> SingleLinkage::make_shared(std::optional<int> num_clusters,
+    std::optional<Scalar> distance_threshold)
+{ return std::make_shared<SingleLinkage>(num_clusters, distance_threshold);}
+
 ClusterAssignment SingleLinkage::predict(Matrix const &data, std::vector<PointId> data_filter) {
     Matrix distance_matrix;
     ClusterAssignment clusters;
@@ -29,13 +33,11 @@ ClusterAssignment SingleLinkage::predict(Matrix const &data, std::vector<PointId
 
     // Initialize distance matrix
     distance_matrix.resize(numdata, std::vector<double>(numdata, 0.0));
-    std::cout << std::setprecision(2) << std::fixed;
     for (auto const i: data_filter) {
         for (auto const j: data_filter) {
             if(j <= i) continue;
             distance_matrix[i][j] = distance_matrix[j][i] = euclididan_distance(data[i], data[j]);
         }
-        std::cout << std::endl;
     }
 
     size_t const num_clusters = _num_clusters.has_value() ? _num_clusters.value() : 1;

SingleLinkage.h

@@ -5,6 +5,7 @@
 #ifndef SINGLELINKAGE_H
 #define SINGLELINKAGE_H
 #include <limits>
+#include <memory>
 #include <optional>
 
 #include "Clusterer.h"
@@ -16,6 +17,8 @@ class SingleLinkage : public Clusterer {
 public:
 
     SingleLinkage(std::optional<int> num_clusters, std::optional<Scalar> distance_threshold);
+    [[nodiscard]] static std::shared_ptr<Clusterer> make_shared(std::optional<int> num_clusters, std::optional<Scalar> distance_threshold);
+
     ClusterAssignment predict(Matrix const &data, std::vector<PointId> data_filter) override;
 
 private: