tidy utils cpp code

Author: mpadge

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: spatialcluster
 Title: R port of redcap
-Version: 0.2.0.013
+Version: 0.2.0.014
 Authors@R: 
     person("Mark", "Padgham", , "mark.padgham@email.com", role = c("aut", "cre"))
 Description: R port of redcap (Regionalization with dynamically

codemeta.json

@@ -7,7 +7,7 @@
   "codeRepository": "https://github.com/mpadge/spatialcluster",
   "issueTracker": "https://github.com/mpadge/spatialcluster/issues",
   "license": "https://spdx.org/licenses/GPL-3.0",
-  "version": "0.2.0.013",
+  "version": "0.2.0.014",
   "programmingLanguage": {
     "@type": "ComputerLanguage",
     "name": "R",

src/utils.cpp

@@ -17,8 +17,7 @@
  * unordered_set of target indices for each cluster.
  */
 
-bool utils::strfound (const std::string str, const std::string target)
-{
+bool utils::strfound (const std::string str, const std::string target) {
     bool found = false;
     if (str.find (target) != std::string::npos)
         found = true;
@@ -31,40 +30,36 @@ size_t utils::sets_init (
         int2indx_map_t &vert2index_map,
         indx2int_map_t &index2vert_map,
         indx2int_map_t &index2cl_map,
-        int2indxset_map_t &cl2index_map)
-{
+        int2indxset_map_t &cl2index_map) {
     vert2index_map.clear ();
     index2vert_map.clear ();
     index2cl_map.clear ();
     cl2index_map.clear ();
 
     intset_t vert_set;
-    for (int i = 0; i < from.size (); i++)
-    {
+    for (int i = 0; i < from.size (); i++) {
         vert_set.emplace (from [i]);
         vert_set.emplace (to [i]);
     }
     int idx = 0;
-    for (auto v: vert_set)
-    {
+    for (auto v: vert_set) {
         index2vert_map.emplace (idx, v);
         vert2index_map.emplace (v, idx++);
     }
 
-    for (int i = 0; i < from.length (); i++)
-    {
+    for (int i = 0; i < from.length (); i++) {
         size_t fi = vert2index_map.at (from [i]);
         indxset_t eset; // only one index for each vert at this stage
         eset.insert (fi);
         cl2index_map.emplace (fi, eset);
     }
-    for (auto v: vert_set)
-    {
+    for (auto v: vert_set) {
         // all verts are their own clusters, so cast indx to cli
         int cli = static_cast <int> (vert2index_map.at (v));
         indxset_t eset;
-        if (cl2index_map.find (cli) != cl2index_map.end ())
+        if (cl2index_map.find (cli) != cl2index_map.end ()) {
             eset = cl2index_map.at (cli);
+        }
         eset.emplace (cli);
         cl2index_map.emplace (cli, eset);
         index2cl_map.emplace (static_cast <size_t> (cli), cli);
@@ -90,60 +85,60 @@ size_t utils::find_shortest_connection (
         const int2indxset_map_t &cl2index_map,
         const int cfrom,
         const int cto,
-        const bool shortest)
-{
-    if (cl2index_map.find (cfrom) == cl2index_map.end ())
+        const bool shortest) {
+    if (cl2index_map.find (cfrom) == cl2index_map.end ()) {
         Rcpp::stop ("cluster index not found");
-    if (cl2index_map.find (cto) == cl2index_map.end ())
+    }
+    if (cl2index_map.find (cto) == cl2index_map.end ()) {
         Rcpp::stop ("cluster index not found");
+    }
 
     indxset_t index_i = cl2index_map.at (cfrom),
              index_j = cl2index_map.at (cto);
 
     double dlim = INFINITE_DOUBLE;
-    if (!shortest)
+    if (!shortest) {
         dlim = -dlim;
+    }
     size_t short_i = INFINITE_INT, short_j = INFINITE_INT;
 
     // from and to here are directional, so need to examine both directions
-    for (auto i: index_i)
-        for (auto j: index_j)
-        {
+    for (auto i: index_i) {
+        for (auto j: index_j) {
             arma::uword ia = static_cast <arma::uword> (i),
                         ja = static_cast <arma::uword> (j);
             if ((shortest && d_mat (ia, ja) < dlim) ||
-                    (!shortest && d_mat (ia, ja) > dlim))
-            {
+                    (!shortest && d_mat (ia, ja) > dlim)) {
                 dlim = d_mat (ia, ja);
                 short_i = i;
                 short_j = j;
             } else if ((shortest && d_mat (ja, ia) < dlim) ||
-                    (!shortest && d_mat (ja, ia) > dlim))
-            {
+                    (!shortest && d_mat (ja, ia) > dlim)) {
                 dlim = d_mat (ja, ia);
                 short_i = j;
                 short_j = i;
             }
         }
-    if (dlim == INFINITE_DOUBLE)
+    }
+    if (dlim == INFINITE_DOUBLE) {
         Rcpp::stop ("no minimal distance; this should not happen");
+    }
 
     // convert short_i and short_j to a single edge 
     // TODO: Make a std::map of vert2dist to avoid this loop
     size_t shortest_edge = INFINITE_INT;
-    for (int i = 0; i < from.length (); i++) // int for Rcpp index
-    {
+    for (int i = 0; i < from.length (); i++) { // int for Rcpp index
         if ((vert2index_map.at (from [i]) == short_i &&
                 vert2index_map.at (to [i]) == short_j) ||
             (vert2index_map.at (from [i]) == short_j &&
-                vert2index_map.at (to [i]) == short_i))
-        {
+                vert2index_map.at (to [i]) == short_i)) {
             shortest_edge = static_cast <size_t> (i);
             break;
         }
     }
-    if (shortest_edge == INFINITE_INT)
-        Rcpp::stop ("shite");
+    if (shortest_edge == INFINITE_INT) {
+        Rcpp::stop ("This shouldn't happen (in utils::find_shortest_connection)");
+    }
 
     return shortest_edge;
 }
@@ -159,20 +154,19 @@ void utils::merge_clusters (
         indx2int_map_t &index2cl_map,
         int2indxset_map_t &cl2index_map,
         const int cluster_from,
-        const int cluster_to)
-{
-    if (cluster_from < 0)
+        const int cluster_to) {
+    if (cluster_from < 0) {
         Rcpp::stop ("cluster_from must be non-negative");
-    if (cluster_to < 0)
+    }
+    if (cluster_to < 0) {
         Rcpp::stop ("cluster_to must be non-negative");
+    }
 
     arma::uword cfr = static_cast <arma::uword> (cluster_from),
                 cto = static_cast <arma::uword> (cluster_to);
     // Set all contig_mat (cluster_from, .) to 1
-    for (arma::uword i = 0; i < contig_mat.n_rows; i++)
-    {
-        if (contig_mat (cfr, i) == 1 || contig_mat (i, cfr) == 1)
-        {
+    for (arma::uword i = 0; i < contig_mat.n_rows; i++) {
+        if (contig_mat (cfr, i) == 1 || contig_mat (i, cfr) == 1) {
             contig_mat (cfr, i) = contig_mat (i, cfr) = 1;
             contig_mat (cto, i) = contig_mat (i, cto) = 1;
         }
@@ -181,23 +175,23 @@ void utils::merge_clusters (
     indxset_t idx_from = cl2index_map.at (cluster_from),
               idx_to = cl2index_map.at (cluster_to);
 
-    for (auto i: idx_from)
-        for (auto j: idx_to)
-        {
+    for (auto i: idx_from) {
+        for (auto j: idx_to) {
             arma::uword ia = static_cast <arma::uword> (i),
                         ja = static_cast <arma::uword> (j);
             contig_mat (ia, ja) = contig_mat (ja, ia) = 1;
         }
+    }
 
     // then re-number all cluster numbers in cl2index 
     cl2index_map.erase (cluster_from);
     cl2index_map.erase (cluster_to);
-    for (auto i: idx_from)
+    for (auto i: idx_from) {
         idx_to.insert (i);
+    }
     cl2index_map.emplace (cluster_to, idx_to);
     // and in index2cl:
-    for (auto i: idx_from)
-    {
+    for (auto i: idx_from) {
         index2cl_map.erase (i);
         index2cl_map.emplace (i, cluster_to);
     }
@@ -214,21 +208,20 @@ void utils_slk::mats_init (
         const int2indx_map_t &vert2index_map,
         arma::Mat <int> &contig_mat,
         arma::Mat <double> &d_mat,
-        bool shortest)
-{
+        bool shortest) {
     // arma::uword = unsigned int
     const arma::uword n = static_cast <arma::uword> (vert2index_map.size ());
 
     contig_mat = arma::zeros <arma::Mat <int> > (n, n);
     //d_mat = arma::zeros <arma::Mat <double> > (n, n);
     d_mat.resize (n, n);
-    if (shortest)
+    if (shortest) {
         d_mat.fill (INFINITE_DOUBLE);
-    else
+    } else {
         d_mat.fill (-INFINITE_DOUBLE);
+    }
 
-    for (int i = 0; i < from.length (); i++)
-    {
+    for (int i = 0; i < from.length (); i++) {
         arma::uword fi = static_cast <arma::uword> (vert2index_map.at (from [i])),
                     ti = static_cast <arma::uword> (vert2index_map.at (to [i]));
         contig_mat (fi, ti) = contig_mat (ti, fi) = 1;

src/utils.h

@@ -4,8 +4,7 @@ namespace utils {
 
 bool strfound (const std::string str, const std::string target);
 
-struct OneEdge
-{
+struct OneEdge {
     int from, to;
     double dist;
 };