LOCO_OUT/ERR/EXIT; first functions for RCPP object writing

Author: tstohn

DESCRIPTION

@@ -9,6 +9,6 @@ Description: Quickly detect local correlation patterns between features in singl
              space from neighbourhood to neighbourhood.
 License: GPL-3.0 license
 LinkingTo: Rcpp
-Imports: Rcpp
+Imports: Rcpp,ggplot2
 SystemRequirements: C++17
 RoxygenNote: 7.1.2

R/loco.R

@@ -65,4 +65,19 @@ run_loco <- function(
   )
 
   return(res)
+}
+
+# TODO: add umap coords to res, when plot_n is called the first time these umap coords are filled
+
+#' Plot correlation for features by neighbourhoods
+#' Therefore create UMAP space first to then plot neighbourhoods into the same space
+#' @import ggplot2
+#' @export
+plot_neighbourhood <- function(res, featureA = "x", featureB = "y") 
+{
+
+
+  p +
+    ggplot2::geom_point(alpha = 0.7) +
+    ggplot2::theme_minimal()
 }

src/GraphData.cpp

@@ -37,8 +37,8 @@ namespace InitializationHelper
             }
             else
             {
-                std::cout << "Error: No distance metric for cell-similarity graph\n";
-                exit(1);
+                LOCO_OUT << "Error: No distance metric for cell-similarity graph\n";
+                LOCO_EXIT(1);
             }
 
             //save the distance
@@ -79,24 +79,24 @@ namespace InitializationHelper
         if(graphData->distances_precalcualted())
         {
             if (statusUpdate)
-                std::cout << "\tSTEP[0a]:\tCalculate kNN cell-cell distances\n";
+                LOCO_OUT << "\tSTEP[0a]:\tCalculate kNN cell-cell distances\n";
 
             graphData->build_knn_adjacency(graphData->get_knn());
 
             if (statusUpdate)
-                std::cout << "\tSTEP[0b]:\tSorting cell-cell distances\n";
+                LOCO_OUT << "\tSTEP[0b]:\tSorting cell-cell distances\n";
 
             graphData->sort_adjacencyList();
         }
         else
         {
             if (statusUpdate)
-                std::cout << "\tSTEP[0a]:\tCreate KD-tree only\n";
+                LOCO_OUT << "\tSTEP[0a]:\tCreate KD-tree only\n";
 
             graphData->create_kd_tree();
 
             if (statusUpdate)
-                std::cout << "Skipping distance calculations and do not fill adj. list\n";
+                LOCO_OUT << "Skipping distance calculations and do not fill adj. list\n";
 
         }
 
@@ -112,17 +112,17 @@ namespace InitializationHelper
 
         if(statusUpdate)
         {
-            std::cout << "\tSTEP[0a]:\tCalculate cell-cell distances\n";
+            LOCO_OUT << "\tSTEP[0a]:\tCalculate cell-cell distances\n";
             if(!graphData->distances_precalcualted())
             {
-                std::cout << "WARNING: Distances get precalcualted despite seeting the flag to not precalcualte!!!\n";
-                std::cout << "Distances can only be NOT calcualted when calcualting distances with the KD-tree\n";
+                LOCO_OUT << "WARNING: Distances get precalcualted despite seeting the flag to not precalcualte!!!\n";
+                LOCO_OUT << "Distances can only be NOT calcualted when calcualting distances with the KD-tree\n";
             }
         }
 
-        std::cout << "CALCULATING DISTANCES FROM \n";
-        for(auto x : cellStateGenes){std::cout << x << " ";}
-        std::cout << "\n";
+        LOCO_OUT << "CALCULATING DISTANCES FROM \n";
+        for(auto x : cellStateGenes){LOCO_OUT << x << " ";}
+        LOCO_OUT << "\n";
 
         //boost::asio::thread_pool pool_dist(threads);
         ThreadPool pool_dist(threads);
@@ -210,11 +210,11 @@ namespace InitializationHelper
         pool_dist.wait_for_tasks();
 
         printProgress(1);
-        std::cout << "\n";
+        LOCO_OUT << "\n";
 
         if(statusUpdate)
         {
-            std::cout << "\tSTEP[0b]:\tSorting cell-cell distances\n";
+            LOCO_OUT << "\tSTEP[0b]:\tSorting cell-cell distances\n";
         }
         //sort the values: before we simply inserted them all to the back
         graphData->sort_adjacencyList();
@@ -419,7 +419,7 @@ if(!corrStateGenes.empty()){geneSize = corrStateGenes.size();}
     {
         //eigenvalues ordered from highest to lowest
         double eigenVal = pca.eigenvalues.at<double>(i);
-        std::cout << "NEXT EIGENVAL: " << eigenVal << "\n";
+        LOCO_OUT << "NEXT EIGENVAL: " << eigenVal << "\n";
     }
 }*/
 
@@ -437,7 +437,7 @@ void GraphData::build_knn_adjacency(int k)
     adjacencyList.clear();
     adjacencyList.reserve(N);  // unordered_map reserve
 
-    std::cout << "creating cell-cell dist with k " << k << "\n";
+    LOCO_OUT << "creating cell-cell dist with k " << k << "\n";
     // 3. For each node, query its k nearest neighbors (the point itself is part of the results and will be added to cells for this N)
     for (size_t i = 0; i < N; ++i)
     {
@@ -488,7 +488,7 @@ void GraphData::build_knn_adjacency(int k)
 
 void GraphData::create_kd_tree()
 {
-    std::cout << "\t# BUILDING KD-TREE\n";
+    LOCO_OUT << "\t# BUILDING KD-TREE\n";
     const int dim = get_node_at(0)->dimensions();
 
     typedef KDTreeVectorOfNodePtrAdaptor<> my_kd_tree_t;
@@ -521,9 +521,9 @@ void GraphData::search_kd_tree()
 
         if(i == nodes.size()-1)
         {
-        	std::cout << "knnSearch(nn="<<num_results<<"): \n";
+        	LOCO_OUT << "knnSearch(nn="<<num_results<<"): \n";
             for (size_t i = 0; i < num_results; i++)
-                std::cout << "ret_index["<<i<<"]=" << ret_indexes[i] << " out_dist_sqr=" << out_dists_sqr[i] << std::endl;
+                LOCO_OUT << "ret_index["<<i<<"]=" << ret_indexes[i] << " out_dist_sqr=" << out_dists_sqr[i] << std::endl;
         }
     }
 }
@@ -561,7 +561,7 @@ void GraphData::brute_force_get_points_within_radius(node node, double radius)
         }
     }
 
-    //std::cout << "MATCHES FOUND: " << solutionNodes.size() << "\n";
+    //LOCO_OUT << "MATCHES FOUND: " << solutionNodes.size() << "\n";
 
 }
 

src/GraphData.hpp

@@ -15,6 +15,7 @@
 #include "correlationUtils.hpp"
 #include "generalUtils.hpp"
 #include "threadPool.hpp"
+#include "loco_io.h"
 
 // vector of positions of the dimensions that contribute to a subspace
 typedef std::vector<int> subSpace;
@@ -268,16 +269,16 @@ class GraphData
         {
             if(!distancesPrecalculated)
             {
-                std::cerr << "requesting to return distances from adjacency list, but they have not been precalcualted!\n";
-                exit(EXIT_FAILURE);
+                LOCO_ERR << "requesting to return distances from adjacency list, but they have not been precalcualted!\n";
+                LOCO_EXIT(EXIT_FAILURE);
             }
 
             std::vector<int> adjNodes;
             const OrderedNeighborDistanceHash neighbors = get_adjacent_nodes(node);
             if(knn > neighbors.size())
             {
-                std::cerr << "Requesting more neighbors from node than it has!!!\n";
-                std::cerr << knn << " requested, but only" << neighbors.size() << " neighbors exist\n";
+                LOCO_ERR << "Requesting more neighbors from node than it has!!!\n";
+                LOCO_ERR << knn << " requested, but only" << neighbors.size() << " neighbors exist\n";
             }
             size_t count = 0;
             for(const std::pair<nodePtr, const double> neighbor : neighbors)
@@ -293,15 +294,15 @@ class GraphData
         {
             if(!distancesPrecalculated)
             {
-                std::cerr << "requesting to return distances from adjacency list, but they have not been precalcualted!\n";
-                exit(EXIT_FAILURE);
+                LOCO_ERR << "requesting to return distances from adjacency list, but they have not been precalcualted!\n";
+                LOCO_EXIT(EXIT_FAILURE);
             }
 
             std::vector<nodePtr> adjNodes;
             const OrderedNeighborDistanceHash neighbors = get_adjacent_nodes(node);
             if(knn > neighbors.size())
             {
-                std::cerr << "Requesting more neighbors from node than it has!!!\n";
+                LOCO_ERR << "Requesting more neighbors from node than it has!!!\n";
             }
             size_t count = 0;
             for(const std::pair<const nodePtr, const double> neighbor : neighbors)
@@ -320,7 +321,7 @@ class GraphData
         {
             if(distancesPrecalculated)
             {
-                std::cout << "WARNING: requesting to return distances from KD-tree but distances were precalcualted!\n";
+                LOCO_OUT << "WARNING: requesting to return distances from KD-tree but distances were precalcualted!\n";
             }
 
             std::vector<int> adjNodes;
@@ -358,7 +359,7 @@ class GraphData
         {
             if(distancesPrecalculated)
             {
-                std::cout << "WARNING: requesting to return distances from KD-tree but distances were precalcualted!\n";
+                LOCO_OUT << "WARNING: requesting to return distances from KD-tree but distances were precalcualted!\n";
             }
             std::vector<nodePtr> adjNodes;
 
@@ -412,15 +413,15 @@ class GraphData
         //writes edges between nodes to terminal
         void print_adjacency_by_name() const
         {            
-            std::cout << "ADJ LIST:\n" << "_______________\n";
+            LOCO_OUT << "ADJ LIST:\n" << "_______________\n";
             for(nodePtr nodeTmp : nodes)
             {
-                std::cout << "FROM: " << nodeTmp->get_name() << "\n";
+                LOCO_OUT << "FROM: " << nodeTmp->get_name() << "\n";
                 for(const std::pair<const nodePtr, const double> neighbor : get_adjacent_nodes(nodeTmp))
                 {
-                    std::cout << neighbor.first->get_name() << "(" << std::to_string(neighbor.second) << ")" << " - ";
+                    LOCO_OUT << neighbor.first->get_name() << "(" << std::to_string(neighbor.second) << ")" << " - ";
                 }
-                std::cout << "\n";
+                LOCO_OUT << "\n";
             }
         }
         void print_adjacency_by_order() const 
@@ -431,21 +432,21 @@ class GraphData
                 for(size_t j = 0; j < nodes.size(); ++j)
                 {
                     double dist = nodeNeighborList.at(nodes.at(j));
-                    std::cout << std::to_string(i) << " " << std::to_string(j) << " " << std::to_string(dist) << "\n"; 
+                    LOCO_OUT << std::to_string(i) << " " << std::to_string(j) << " " << std::to_string(dist) << "\n"; 
                 }
             }
         }
 
         //writes nodes and their values to terminal
         void print_data()
         {
-            std::cout << "NODE VECTORS:\n" << "_______________\n";
+            LOCO_OUT << "NODE VECTORS:\n" << "_______________\n";
             for(nodePtr nodeTmp : nodes)
             {
-                std::cout << "#: " << nodeTmp->get_name() << "\n";
+                LOCO_OUT << "#: " << nodeTmp->get_name() << "\n";
                 for( const double& dim : nodeTmp->all_values())
                 {
-                    std::cout << std::to_string(dim) << "\n";
+                    LOCO_OUT << std::to_string(dim) << "\n";
                 }
             }
         }

src/GraphHandler.cpp

@@ -112,9 +112,9 @@ void GraphHandler::fill_distance_matrix(double** weightMatrix)
     bool descending = data->is_node_order_descending();
     if( (descending == true) && bandwidth != -1)
     {
-        std::cerr << "When nodes are in descending order we can not apply gaussian kernel, we assumes this is use for protein \
+        LOCO_ERR << "When nodes are in descending order we can not apply gaussian kernel, we assumes this is use for protein \
         correclation graphs, where only un-scaled values make sense \n";
-        std::exit(EXIT_FAILURE);
+        LOCO_EXIT(EXIT_FAILURE);
     }
 
     int numberNodes = data->number_of_nodes();
@@ -179,8 +179,8 @@ void GraphHandler::fill_knn_matrix(double** weightMatrix)
 {
     if(data->is_node_order_descending() == true)
     {
-        std::cerr << "For KNN graphs we must order nodes in ascending order \n";
-        std::exit(EXIT_FAILURE);
+        LOCO_ERR << "For KNN graphs we must order nodes in ascending order \n";
+        LOCO_EXIT(EXIT_FAILURE);
     }
     int numberNodes = data->number_of_nodes();
     //initialize matrix with zeroes

src/GraphHandler.hpp

@@ -9,6 +9,7 @@
 #include <unordered_map>
 #include <exception>
 #include <numeric>
+#include "loco_io.h"
 
 #include "GraphData.hpp"
 
@@ -103,8 +104,8 @@ class GraphHandler
             //this only works for KNN graphs, not for K-DIST graphs
             if(knn == 0)
             {
-                std::cerr << "Error: Can not calculate neighbors when knn is set to zero";
-                exit(EXIT_FAILURE);
+                LOCO_ERR << "Error: Can not calculate neighbors when knn is set to zero";
+                LOCO_EXIT(EXIT_FAILURE);
             }
 
             //get all neighbors from data (fastest way, it has all neighbors ordered)