Some fixes and clean CRAN CHECK

dirmeier · dirmeier · commit 1aef3bc01a26 · 2017-10-29T12:50:00.000+01:00
diff --git a/.lintr b/.lintr
@@ -6,11 +6,10 @@ linters: list(linelen=line_length_linter(80),
               snakelinter=snake_case_linter,
               closedcurly=closed_curly_linter,
               trailingwhites=trailing_whitespace_linter)
-exclusions: list("tests/testthat.R", 
+exclusions: list("tests/testthat.R",
                  "tests/testthat/test_knn.R",
                  "tests/testthat/test_mrw.R",
-                 "tests/testthat/test_insulated_heat.R",
-                 "tests/testthat/test_laplacian_heat.R",
+                 "tests/testthat/test_heat.R",
                  "tests/testthat/test_util.R",
                  "inst/doc/diffusr.R",
                  "R/RcppExports.R")
diff --git a/.travis.yml b/.travis.yml
@@ -1,6 +1,5 @@
 language: r
 r:
-  - oldrel
   - release
   - devel
 
@@ -12,9 +11,7 @@ cache: packages
 r_packages:
   - covr
   - testthat
-
-r_github_packages:
-  - jimhester/lintr
+  - lintr
 
 env:
   global:
diff --git a/DESCRIPTION b/DESCRIPTION
@@ -2,12 +2,13 @@ Package: diffusr
 Type: Package
 Title: Network Diffusion Algorithms
 Version: 0.1.2
-Authors@R: person("Simon", "Dirmeier", 
+Date: 2017-10-29
+Authors@R: person("Simon", "Dirmeier",
                   email = "simon.dirmeier@gmx.de",
                   role = c("aut", "cre"))
 Maintainer: Simon Dirmeier <simon.dirmeier@gmx.de>
 Description: Implementation of network diffusion algorithms such as
-  heat diffusrion or Markov random walks. Network diffusion algorithms generally
+  heat diffusion or Markov random walks. Network diffusion algorithms generally
   spread information in the form of node weights along the edges of a graph to other nodes.
   These weights can for example be interpreted as temperature, an initial amount
   of water, the activation of neurons in the brain, or the location of a random
diff --git a/R/heat_diffusion.R b/R/heat_diffusion.R
@@ -86,8 +86,8 @@ setMethod(
       message("setting diag of graph to zero")
       diag(graph) <- 0
     }
-    invisible(heat_diffusion_(h0,
-                              normalize.laplacian(graph),
-                              t))
+
+    invisible(
+      heat_diffusion_(h0, normalize.laplacian(graph), t))
   }
 )
diff --git a/R/mat_util.R b/R/mat_util.R
@@ -91,8 +91,7 @@ normalize.laplacian.numeric <- function(obj, ...)
 {
   adj   <- igraph::graph_from_adjacency_matrix(obj,
                                                mode="directed",
-                                               weighted=T)
+                                               weighted=TRUE)
   comps <- igraph::components(adj)
   ifelse(length(comps$csize) == 1, TRUE, FALSE)
 }
-
diff --git a/R/mrw.R b/R/mrw.R
@@ -106,14 +106,8 @@ setMethod(
 
     stoch.graph <- normalize.stochastic(graph)
     if(!.is.ergodic(stoch.graph))
-      stop("the provided graph has more than one component. It is likely not ergodic.")
-
-    print(p0)
-    print(stoch.graph)
-    print(r)
-    print(thresh)
-    print(niter)
-    print(do.analytical)
+      stop(paste("the provided graph has more than one component.",
+                 "It is likely not ergodic."))
 
     invisible(
       mrwr_(normalize.stochastic(p0),
diff --git a/R/neighbors.R b/R/neighbors.R
@@ -79,7 +79,7 @@ setMethod(
     }
     l <- neighbors_(int.nodes, graph, k)
     names(l) <- int.nodes
+    
     invisible(l)
   }
 )
-
diff --git a/diffusr.Rproj b/diffusr.Rproj
diff --git a/src/heat_diffusion.cpp b/src/heat_diffusion.cpp
@@ -44,7 +44,9 @@ Eigen::MatrixXd heat_diffusion_(const Eigen::MatrixXd& v0,
   Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es(W);
   Eigen::MatrixXd V = es.eigenvectors();
   Eigen::VectorXd D = es.eigenvalues();
-  Eigen::VectorXd co =  V.transpose() * v0;
+  Eigen::MatrixXd co =  V.transpose() * v0;
+  
+  // solution to the heat equation at time t
   for (int i = 0; i < co.rows(); ++i)
   {
     for (int j = 0; j < co.cols(); ++j)
diff --git a/src/mrw.cpp b/src/mrw.cpp
@@ -23,7 +23,6 @@
 // [[Rcpp::depends(RcppEigen)]]
 #include <RcppEigen.h>
 #include <vector>
-#include <iostream>
 
 //' Do a Markon random walk (with restart) on an column-normalised adjacency
 //' matrix.
diff --git a/src/neighbors.cpp b/src/neighbors.cpp
@@ -64,14 +64,18 @@ void nearest_neighbor_dijkstra_(std::set<int>& nei,
     // get the nearest neighbor and add him to the list
     std::pair<int, double> cn = queue.top();
     queue.pop();
-    if (!visited[cn.first]) curr_nei.push_back(cn);
+    if (!visited[cn.first])
+    {
+      curr_nei.push_back(cn);
+    }
     // add neighbors that are as close as the first neighbor
     while (equals(queue.top().second, cn.second, .001) && queue.size())
     {
       std::pair<int, double> nn = queue.top();
       if (!visited[nn.first]) curr_nei.push_back(nn);
       queue.pop();
     }
+
     for (std::vector<std::pair<int, double>>::size_type i = 0;
          i < curr_nei.size(); ++i)
     {
@@ -80,8 +84,12 @@ void nearest_neighbor_dijkstra_(std::set<int>& nei,
       else visited[cn.first] = true;
       nei.insert(cn.first + 1);
       for (int i = 0; i < W.cols(); ++i)
+      {
         if (i != cn.first && W(cn.first, i) > 0)
+        {
           queue.push(std::make_pair(i, W(cn.first, i)));
+        }
+      }
     }
   }
   while (r++ < max_depth && queue.size());
@@ -115,5 +123,6 @@ Rcpp::List neighbors_(const Rcpp::IntegerVector& node_idxs,
     // run disjkstra until k neighbors are found
     nearest_neighbor_dijkstra_(neighbors[i], node_idx, k, W);
   }
+
   return Rcpp::wrap(neighbors);
 }
diff --git a/tests/testthat/test_heat.R b/tests/testthat/test_heat.R
@@ -34,14 +34,22 @@ test_that("heat diffusion if maximum diffusion",{
   expect_equal(as.vector(s), expect, 0.001)
 })
 
+test_that("heat diffusion matrix if maximum diffusion",  {
+  p0 <- matrix(0, nrow=5, ncol=10)
+  p0[1,] <- 1
+  expect <- matrix(1/5, nrow=5, ncol=10)
+  mat.heat <- heat.diffusion(p0, adja, 1000000)
+  expect_equal(mat.heat, expect, 0.0001)
+})
+
 test_that("heat diffusion vectorial is same as with matrix",  {
-  p0 <- matrix(rep(1:10, each=20), nrow=5)
-  mat.heat <- heat.diffusion(p0, adja, .5)
+  p0 <- matrix(rep(1:10, each=5), nrow=5)
+  mat.heat <- heat.diffusion(p0, adja, 1000000)
   vec.heat <- sapply(seq(ncol(p0)), function(e) {
       p <- heat.diffusion(p0[, e], adja, .5)
       p
   })
-  expect_equal(mat.walk, vec.walk, 0.0001)
+  expect_equal(mat.heat, vec.heat, 0.0001)
 })
 
 test_that("wrong t negative values", {
diff --git a/vignettes/diffusr.Rmd b/vignettes/diffusr.Rmd
@@ -106,7 +106,7 @@ You can use the *Laplacian heat diffusion process* like this:
   # adjacency matrix (either normalized or not)
   graph <- matrix(abs(rnorm(n*n)), n, n)
   # computation of stationary distribution
-  ht    <- laplacian.heat.diffusion(h0, graph)
+  ht    <- heat.diffusion(h0, graph)
 ```
 
 Here are the results:
@@ -118,7 +118,7 @@ Here are the results:
 
 As before, `p0` can also be a matrix:
 ```{r, message=F, warning=F}
-   p0 <- matrix(c(p0, runif(20)), nrow=n)
-   pt <- random.walk(p0, graph)
-   pt
+   h0 <- matrix(c(h0, runif(20)), nrow=n)
+   ht <- heat.diffusion(h0, graph)
+   ht
 ```

Original file line number	Diff line number	Diff line change
`@@ -86,8 +86,8 @@ setMethod(`
`86`	`86`	`message("setting diag of graph to zero")`
`87`	`87`	`diag(graph) <- 0`
`88`	`88`	`}`
`89`		`- invisible(heat_diffusion_(h0,`
`90`		`- normalize.laplacian(graph),`
`91`		`- t))`
	`89`	`+`
	`90`	`+ invisible(`
	`91`	`+ heat_diffusion_(h0, normalize.laplacian(graph), t))`
`92`	`92`	`}`
`93`	`93`	`)`
Original file line number	Diff line number	Diff line change
`@@ -91,8 +91,7 @@ normalize.laplacian.numeric <- function(obj, ...)`
`91`	`91`	`{`
`92`	`92`	`adj <- igraph::graph_from_adjacency_matrix(obj,`
`93`	`93`	`mode="directed",`
`94`		`- weighted=T)`
	`94`	`+ weighted=TRUE)`
`95`	`95`	`comps <- igraph::components(adj)`
`96`	`96`	`ifelse(length(comps$csize) == 1, TRUE, FALSE)`
`97`	`97`	`}`
`98`		`-`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ setMethod(`
`79`	`79`	`}`
`80`	`80`	`l <- neighbors_(int.nodes, graph, k)`
`81`	`81`	`names(l) <- int.nodes`
	`82`	`+`
`82`	`83`	`invisible(l)`
`83`	`84`	`}`
`84`	`85`	`)`
`85`		`-`