Dev

DESCRIPTION

@@ -1,8 +1,8 @@
 Package: clustur
 Type: Package
 Title: Clustering
-Version: 0.1.3.9000
-Date: 2025-04-15
+Version: 0.1.4
+Date: 2025-12-12
 Authors@R: c(
     person("Gregory", "Johnson", , "grejoh@umich.edu", role = c("aut"),
             comment = c(ORCID = "0009-0008-3890-0297")),

NEWS.md

@@ -1,5 +1,10 @@
-# clustur (development version)
+# clustur 0.1.4
+* Updated the `cluster()` function to change the current clustering metric it is using if it is not suitable for your data.
+
+* `read_dist()` and `cluster()` will now return objects with class name "distance_object", and "mothur_cluster" respectively. This will ensure the returned object can be differentiated between other R objects.
+
+* Fixed memory leaks that were found using Valgrind.
 
 # clustur 0.1.3
 
-* Fixed `Cluster()` returning duplicate cluster names when using method = "opticlust."
+* Fixed `cluster()` returning duplicate cluster names when using method = "opticlust."

R/cluster.R

@@ -38,19 +38,27 @@
 read_dist <- function(distance_file, count_table,
                       cutoff, is_similarity_matrix = FALSE) {
   count_table <- validate_count_table(count_table)
-
-  if ("character" %in% class(distance_file)) {
+  if (inherits(distance_file, "character")) {
     if (!file.exists(distance_file)) {
       stop("Invalid file path: please enter a new file path.")
     }
-    return(ProcessDistanceFiles(distance_file,
-                                count_table, cutoff, is_similarity_matrix))
+    result <- ProcessDistanceFiles(distance_file,
+                                   count_table, cutoff, is_similarity_matrix)
+    class(result) <- "distance_object"
+    return(result)
   }
 
   # Its a sparse matrix not a path
   # filter out the sparse matrix
-  return(ProcessSparseMatrix(distance_file@i, distance_file@j, distance_file@x,
-                             count_table, cutoff, is_similarity_matrix))
+  if (!inherits(distance_file, "dgTMatrix")) {
+    stop("If you are not using a file, ensure the sparse matrix is created from
+     the `create_sparse_matrix()` function")
+  }
+  result <- ProcessSparseMatrix(distance_file@i, distance_file@j,
+                                distance_file@x,
+                                count_table, cutoff, is_similarity_matrix)
+  class(result) <- "distance_object"
+  result
 }
 
 
@@ -99,7 +107,7 @@ read_dist <- function(distance_file, count_table,
 cluster <- function(distance_object, cutoff, method = "opticlust",
                     feature_column_name_to = "feature",
                     bin_column_name_to = "bin", random_seed = 123) {
-  if (!("externalptr" %in% class(distance_object))) {
+  if (!inherits(distance_object, "distance_object")) {
     stop("`distance_object` must be generated using the `read_dist` function")
   }
   if (!(method %in% c("opticlust",
@@ -108,9 +116,10 @@ cluster <- function(distance_object, cutoff, method = "opticlust",
          average, or weighted.")
   }
   set.seed(random_seed)
+  df <- data.frame()
   if (method != "opticlust") {
-    return(Cluster(distance_object, method,
-                   feature_column_name_to, bin_column_name_to, cutoff))
+    df <- Cluster(distance_object, method,
+                  feature_column_name_to, bin_column_name_to, cutoff)
   } else {
     df <- OptiCluster(distance_object, feature_column_name_to,
                       bin_column_name_to, cutoff)
@@ -121,8 +130,10 @@ cluster <- function(distance_object, cutoff, method = "opticlust",
                                                      "specificity", "ppv",
                                                      "npv", "fdr", "accuracy",
                                                      "mcc", "f1score")]
-    return(df)
+
   }
+  class(df) <- "mothur_cluster"
+  df
 }
 
 #' Validate Count Table
@@ -148,7 +159,7 @@ validate_count_table <- function(count_table_df) {
   count_table_df <- cbind(count_table_df, totals)
   names(count_table_df)[3] <- "no_group"
   count_table_df[[1]] <- as.character(count_table_df[[1]])
-  return(count_table_df)
+  count_table_df
 }
 
 #' Example Path
@@ -172,7 +183,7 @@ example_path <- function(file = NULL) {
   } else {
     path <- system.file("extdata", file, package = "clustur", mustWork = TRUE)
   }
-  return(path)
+  path
 }
 
 
@@ -196,7 +207,7 @@ read_count <- function(count_table_path) {
     ct <- CreateDataFrameFromSparseCountTable(count_table_sparse)
     return(validate_count_table(ct))
   }
-  return(validate_count_table(read.delim(count_table_path, sep = "\t")))
+  validate_count_table(read.delim(count_table_path, sep = "\t"))
 }
 
 #' Create Sparse Matrix
@@ -217,5 +228,5 @@ read_count <- function(count_table_path) {
 #' @export
 create_sparse_matrix <- function(i_index, j_index, distances) {
   size <- max(i_index, j_index)
-  return(spMatrix(size, size, i_index, j_index, distances))
+  spMatrix(size, size, i_index, j_index, distances)
 }

R/cluster_data_converters.R

@@ -24,5 +24,5 @@ split_clusters_to_list <- function(cluster) {
     ls[[cluster_df[[2]][[i]]]] <-
       as.list(el(strsplit(cluster_df[[1]][[i]], ",")))
   }
-  return(ls)
+  ls
 }

R/cluster_object-getters.R

@@ -15,12 +15,12 @@
 #' @export
 
 get_cutoff <- function(cluster_data) {
-  if (!("list" %in% class(cluster_data)) ||
+  if (!inherits(cluster_data, "mothur_cluster") ||
         is.null(cluster_data$label)) {
     stop("Ensure `cluster_data` is the object generated from the
     `cluster` function.")
   }
-  return(cluster_data$label)
+  cluster_data$label
 }
 
 
@@ -41,12 +41,12 @@ get_cutoff <- function(cluster_data) {
 #'
 #' @return the created cluster `data.frame`.
 get_bins <- function(cluster_data) {
-  if (!("list" %in% class(cluster_data)) ||
+  if (!inherits(cluster_data, "mothur_cluster") ||
         is.null(cluster_data$cluster)) {
     stop("Ensure `cluster_data` is the object generated from the
     `cluster` function.")
   }
-  return(cluster_data$cluster)
+  cluster_data$cluster
 }
 
 
@@ -67,12 +67,12 @@ get_bins <- function(cluster_data) {
 #'
 #' @return a shared data.frame
 get_abundance <- function(cluster_data) {
-  if (!("list" %in% class(cluster_data)) ||
+  if (!inherits(cluster_data, "mothur_cluster")  ||
         is.null(cluster_data$abundance)) {
     stop("Ensure `cluster_data` is the object generated from the
     `cluster` function.")
   }
-  return(cluster_data$abundance)
+  cluster_data$abundance
 }
 
 
@@ -93,11 +93,11 @@ get_abundance <- function(cluster_data) {
 #'
 #' @return a list of metric data.frames
 get_metrics <- function(cluster_data) {
-  if (!("list" %in% class(cluster_data)) ||
+  if (!inherits(cluster_data, "mothur_cluster") ||
         is.null(cluster_data$cluster_metrics)) {
     stop("Can only use the get_metrics function when an 
     object is clustered using the opticluster method")
   }
-  return(list(metrics = cluster_data$cluster_metrics,
-              iteration_metrics = cluster_data$iteration_metrics))
+  list(metrics = cluster_data$cluster_metrics,
+       iteration_metrics = cluster_data$iteration_metrics)
 }

R/distance_object-getters.R

@@ -14,10 +14,10 @@
 #'
 #' @return a count_table `data.frame`.
 get_count_table <- function(distance_object) {
-  if (!inherits(distance_object, "externalptr"))
+  if (!inherits(distance_object, "distance_object"))
     stop("The distance object must be the object generated when
          calling the `read_dist` function.")
-  return(GetCountTable(distance_object))
+  GetCountTable(distance_object)
 }
 
 #' Get Distance Data Frame
@@ -36,9 +36,9 @@ get_count_table <- function(distance_object) {
 #'
 #' @return a distance `data.frame`.
 get_distance_df <- function(distance_object) {
-  if (!inherits(distance_object, "externalptr"))
+  if (!inherits(distance_object, "distance_object"))
     stop("The distance object must be the object generated when
          calling the `read_dist` function.")
   df <- GetDistanceDataFrame(distance_object)
-  return(df)
+  df
 }

src/Adapters/CountTableAdapter.h

@@ -13,34 +13,26 @@
 #include <set>
 
 
-
 class CountTableAdapter {
 public:
     CountTableAdapter() = default;
-    bool CreateDataFrameMap(const Rcpp::DataFrame& countTable);
+    bool CreateDataFrameMap(const Rcpp::DataFrame& count);
     bool CreateDataFrameMapFromSparseCountTable(const Rcpp::DataFrame& countTable);
-    std::vector<std::string> GetSamples() const {return sampleNames;}
+    std::vector<std::string> GetSequences() const {return sequenceNames;}
     // Going to ensure that each count_table atleast has a group
     // And if there is no count table inputted, I will create a base one.
     double FindAbundanceBasedOnGroup(const std::string& group, const std::string& sampleName) const;
     double FindTotalAbundance(const std::string& sampleName) const;
-    std::string GetNameByIndex(int) const;
+    std::string GetNameByIndex(size_t) const;
     std::vector<double> GetColumnByName (const std::string& name) const;
     std::vector<std::string> GetGroups() const;
-    Rcpp::DataFrame GetCountTable() const {return countTable;}
     Rcpp::DataFrame ReCreateDataFrame() const;
 private:
     void CreateNameToIndex();
-    struct IndexAbundancePair {
-        int groupIndex;
-        int sequenceIndex;
-        double abundance;
-    };
     std::unordered_map<std::string, size_t> nameToRowIndex;
-    std::vector<std::string> sampleNames;
+    std::vector<std::string> sequenceNames;
     std::unordered_map<std::string, std::vector<double>> dataFrameMap;
     std::vector<std::string> groups;
-    Rcpp::DataFrame countTable{};
 };
 
 

src/Adapters/DistanceFileReader.h

@@ -14,30 +14,33 @@
 class DistanceFileReader {
 public:
     virtual ~DistanceFileReader() = default;
+    DistanceFileReader() = default;
     // We need to deduce type, the easy way to do that is to see if there is a number for the first item read.
     // Phylip files have a number of sequences located at the top. We can use that to our advantage.
     virtual bool Read(const std::string& filePath) {return false;}
-    DistanceFileReader(SparseDistanceMatrix*, ListVector*, double, bool);
-    DistanceFileReader() = default;
+    virtual std::set<std::string> GetFailureParameters() {return failureParameters;};
+    DistanceFileReader(const SparseDistanceMatrix&, const ListVector&, CountTableAdapter , double, bool);
+    DistanceFileReader(const SparseDistanceMatrix&, const ListVector&, double, bool);
+    explicit DistanceFileReader(CountTableAdapter);
     // Phylip files do not need a count table
-    SparseDistanceMatrix* GetSparseMatrix() const {return new SparseDistanceMatrix(*sparseMatrix);}
-    ListVector* GetListVector() const {return new ListVector(*list);}
-    void SetCountTable(CountTableAdapter data);
+    SparseDistanceMatrix* GetSparseMatrix() const {return new SparseDistanceMatrix(sparseMatrix);}
+    ListVector* GetListVector() const {return new ListVector(list);}
     Rcpp::DataFrame SparseMatrixToDataFrame() const;
+    void SetCountTableAdapter(const CountTableAdapter& adapter);
     Rcpp::DataFrame GetCountTable() const;
     CountTableAdapter GetCountTableAdapter() const {return countTable;}
     double GetCutoff() const {return cutoff;}
     bool GetIsSimularity() const {return sim;}
-    void CreateCountTableAdapter(const Rcpp::DataFrame&);
 
 
 
 protected:
-    SparseDistanceMatrix* sparseMatrix{};
+    SparseDistanceMatrix sparseMatrix{};
     CountTableAdapter countTable;
-    ListVector* list{};
+    ListVector list{};
     double cutoff = 0;
     bool sim = true;
+    std::set<std::string> failureParameters; //If we fail to read the file or anything else
 private:
 
 

src/Adapters/MatrixAdapter.h

@@ -15,7 +15,7 @@ class MatrixAdapter {
     MatrixAdapter(const std::vector<int> &iIndexes, const std::vector<int> &jIndexes,
         const std::vector<double> &dataValues, double cutOff, bool isSimularity, CountTableAdapter table);
     ~MatrixAdapter() = default;
-    SparseDistanceMatrix CreateSparseMatrix();
+    SparseDistanceMatrix CreateSparseMatrix() const;
     ListVector CreateListVector() const;
 
 private:

src/ClusterCommand.cpp

@@ -62,6 +62,12 @@ ClusterExport* ClusterCommand::runOptiCluster(OptiMatrix *optiMatrix, const doub
     cutoffs.insert(std::to_string(cutoff));
 
     OptiData *matrix = optiMatrix;
+    if (!matrix->mccValidCalc()) {
+        Rcpp::warning("[WARNING]: The mcc metric is not suitible for your data with a cutoff of " +
+            std::to_string(cutoff) + " using tptn instead.");
+        delete metric;
+        metric = new TPTN();
+    }
     for (auto it = cutoffs.begin(); it != cutoffs.end(); it++) {
         OptiCluster cluster(matrix, metric, 0);
         int iters = 0;
@@ -107,21 +113,21 @@ ClusterExport* ClusterCommand::runOptiCluster(OptiMatrix *optiMatrix, const doub
             }
             util.AddRowToDataFrameMap(dataframeMapClusterMetrics, clusterMetrics, clusterMetricsHeaders);
         }
-        ListVector *list = nullptr;
+        // ListVector *list = nullptr;
         // clusterMetrics += "\n\n";
-        list = cluster.getList();
-        list->setLabel(std::to_string(cutoff));
+        ListVector list = cluster.getList();
+        list.setLabel(std::to_string(cutoff));
         //
         if (printHeaders) {
             //only print headers the first time
             printHeaders = false;
-        } else { list->setPrintedLabels(printHeaders); }
+        } else { list.setPrintedLabels(printHeaders); }
         OptiClusterInformation clusterInformation;
         clusterInformation.label = std::to_string(cutoff);
         clusterInformation.numberOfOtu = static_cast<int>(numBins);
-        clusterInformation.clusterBins = list->print(listFile);
+        clusterInformation.clusterBins = list.print(listFile);
         data->AddToData(clusterInformation);
-        data->SetListVector(*list, std::to_string(cutoff));
+        data->SetListVector(list, std::to_string(cutoff));
         stats = cluster.getStats(tp, tn, fp, fn);
 
         sensFile += std::to_string(cutoff) + ',' + std::to_string(cutoff) + ',' + std::to_string(tp) + ',' +
@@ -130,7 +136,6 @@ ClusterExport* ClusterCommand::runOptiCluster(OptiMatrix *optiMatrix, const doub
         for (double result: stats) { sensFile += std::to_string(result) + ','; }
         util.AddRowToDataFrameMap(dataframeMapSensMetrics, sensFile, sensfileHeaders);
     }
-    delete matrix;
     return data;
 }
 
@@ -175,13 +180,13 @@ ClusterExport* ClusterCommand::runMothurCluster(const std::string &clusterMethod
 
         if(!data.label.empty()) {
             data.clusterBins = oldList.print(listFile);
-            auto* vec = new ListVector(oldList);
+            ListVector listVec(oldList);
             list->setPrintedLabels(false);
             clusterData->AddToData(data);
             if(rndPreviousDist > highestDistLabel) {
                 highestDistLabel = rndPreviousDist;
-                vec->setLabel(std::to_string(highestDistLabel));
-                clusterData->SetListVector(*vec, std::to_string(highestDistLabel)); // vec might be a shallow copy
+                listVec.setLabel(std::to_string(highestDistLabel));
+                clusterData->SetListVector(listVec, std::to_string(highestDistLabel)); // vec might be a shallow copy
             }
         }
         oldList = *list;
@@ -201,13 +206,12 @@ ClusterExport* ClusterCommand::runMothurCluster(const std::string &clusterMethod
 
     if(!data.label.empty()) {
         data.clusterBins = oldList.print(listFile);
-        auto* vec = new ListVector(oldList);
-
+        ListVector listVec(oldList);
         clusterData->AddToData(data);
         if(rndPreviousDist > highestDistLabel) {
             highestDistLabel = rndPreviousDist;
-            vec->setLabel(std::to_string(highestDistLabel));
-            clusterData->SetListVector(*vec, std::to_string(highestDistLabel));
+            listVec.setLabel(std::to_string(highestDistLabel));
+            clusterData->SetListVector(listVec, std::to_string(highestDistLabel));
         }
     }
     delete(cluster);