Merge pull request #83 from SpatLyu/dev

remove leading lagged NA/NaN values for surd ts defination

Author: SpatLyu

NEWS.md

@@ -1,5 +1,9 @@
 # infoxtr 0.3
 
+### breaking changes
+
+* Remove leading lag-induced NA values in `surd` time-series implementation (#83).
+
 # infoxtr 0.2
 
 ### enhancements

inst/include/infoxtr/lagg.hpp

@@ -1,4 +1,4 @@
-/*******************************************************************
+/*****************************************************************************************
  *  File: lagg.hpp
  *
  *  Lagged aggregation utilities for matrices.
@@ -44,9 +44,21 @@
  *      lagg(mat, lag, byrow)
  *          Temporal lag for time series
  *
+ * Parameter Constraints
+ * 
+ *     Lattice graphs
+ *         large lag values beyond the graph diameter have no additional effect.
+ *         The algorithm automatically stops when no further neighbors are reachable.
+ * 
+ *     Regular grids
+ *         lag must not exceed the maximum grid dimension
+ * 
+ *     Time series
+ *         lag must be smaller than the number of observations
+ *
  *  Author: Wenbo Lyu (Github: @SpatLyu)
  *  License: GPL-3
- *******************************************************************/
+ *****************************************************************************************/
 
 #ifndef INFOXTR_LAGG_HPP
 #define INFOXTR_LAGG_HPP
@@ -55,7 +67,6 @@
 #include <cmath>
 #include <limits>
 #include <algorithm>
-#include <unordered_set>
 #include <stdexcept>
 #include <cstddef>
 
@@ -89,6 +100,9 @@ namespace lagg
         bool byrow = true
     )
     {
+        if (mat.empty())
+            throw std::invalid_argument("Input matrix is empty.");
+
         const size_t n = nb.size();
         const size_t p = mat.front().size();
 
@@ -182,7 +196,10 @@ namespace lagg
         size_t lag = 1,
         bool byrow = true
     )
-    {
+    {   
+        if (mat.empty())
+            throw std::invalid_argument("Input matrix is empty.");
+
         const size_t N = mat.size();
         const size_t p = mat.front().size();
 
@@ -191,6 +208,9 @@ namespace lagg
 
         const size_t ncols = N / nrows;
 
+        if (lag > std::max(nrows, ncols))
+            throw std::invalid_argument("lag too large for grid dimensions.");
+
         Matrix out;
         if (byrow)
             out.assign(N, Vector(p, NaN));
@@ -275,9 +295,15 @@ namespace lagg
         size_t lag = 1,
         bool byrow = true
     )
-    {
+    {   
+        if (mat.empty())
+            throw std::invalid_argument("Input matrix is empty.");
+
         const size_t n = mat.size();
         const size_t p = mat.front().size();
+
+        if (lag >= n)
+            throw std::invalid_argument("lag must be smaller than number of observations.");
 
         Matrix out;
         if (byrow)

inst/include/infoxtr/transferentropy.hpp

@@ -156,7 +156,7 @@ namespace transferentropy
         size_t ag_lag = lag_single ? ag.size() : ag.size() * lag_q;
         size_t N = n_obs - t0;
         DiscMat pm(tg.size() + ag_lag + tg_lag,
-                   std::vector<uint64_t>(N,0));
+                   std::vector<uint64_t>(N, 0));
 
         // Y_present
         for (size_t i = 0; i < tg.size(); ++i)

src/SURD.cpp

@@ -189,6 +189,20 @@ Rcpp::List RcppSURD(const Rcpp::NumericMatrix& mat,
         );
     }
 
+    // Remove leading lagged NA (time series only)
+    if (nb.isNull() && nrows.isNull())
+    {
+        size_t lag_abs = static_cast<size_t>(std::abs(lag));
+
+        if (lag_abs > 0 && lag_abs < n_obs)
+        {
+            for (auto& vec : pm)
+            {
+                vec.erase(vec.begin(), vec.begin() + lag_abs);
+            }
+        }
+    }
+
     infoxtr::surd::SURDRes res = infoxtr::surd::surd(
         pm, 
         static_cast<size_t>(std::abs(max_order)),