Merge branch 'main' into iterated-filtering

Author: stewid

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: SimInf
 Title: A Framework for Data-Driven Stochastic Disease Spread Simulations
-Version: 9.8.1.9000
+Version: 10.1.0.9000
 Authors@R: c(person("Stefan", "Widgren", role = c("aut", "cre"),
                     email = "stefan.widgren@gmail.com",
                     comment = c(ORCID = "0000-0001-5745-2284")),

NEWS.md

@@ -1,5 +1,17 @@
 # SimInf (development version)
 
+## CHANGES OR IMPROVEMENTS
+
+# SimInf 10.1.0 (2025-11-16)
+
+## CHANGES OR IMPROVEMENTS
+
+* Internal change to avoid using memcpy on zero-length continuous
+  state vector, i.e., access elements of a 0-length R vector. This was
+  uncovered by checks on M1mac system on CRAN.
+
+# SimInf 10.0.0 (2025-11-13)
+
 ## BREAKING CHANGES
 
 Backwards incompatible changes that are the reason why the major
@@ -47,6 +59,9 @@ version has been incremented.
 * The `GNU Indent` program has been used to style the C code for
   consistency and readability.
 
+* Add a function to calculate the Lambert W0 function using the GNU
+  Scientific Library (GSL).
+
 # SimInf 9.8.1 (2024-06-21)
 
 ## CHANGES OR IMPROVEMENTS

src/solvers/SimInf_solver.c

@@ -1012,16 +1012,19 @@ SimInf_compartment_model_create(
     const ptrdiff_t Nrep = args->Nrep;
     const ptrdiff_t Nn = args->Nn;
     const ptrdiff_t Nd = args->Nd;
-    model[0].v = malloc(Nrep * Nn * Nd * sizeof(double));
+    const ptrdiff_t v_len = Nrep * Nn * Nd * sizeof(double);
+    model[0].v = malloc(v_len);
     if (!model[0].v)
         goto on_error;          /* #nocov */
-    model[0].v_new = malloc(Nrep * Nn * Nd * sizeof(double));
+    model[0].v_new = malloc(v_len);
     if (!model[0].v_new)
         goto on_error;          /* #nocov */
 
     /* Set continuous state to the initial state in each node. */
-    memcpy(model[0].v, args->v0, Nrep * Nn * Nd * sizeof(double));
-    memcpy(model[0].v_new, args->v0, Nrep * Nn * Nd * sizeof(double));
+    if (v_len > 0) {
+        memcpy(model[0].v, args->v0, v_len);
+        memcpy(model[0].v_new, args->v0, v_len);
+    }
 
     /* Setup vector to keep track of nodes that must be updated due to
      * scheduled events */

src/solvers/SimInf_solver_aem.c

@@ -410,11 +410,16 @@ SimInf_solver_aem(
 
                 /* Copy continuous state to V */
                 while (sa.V && sa.V_it < sa.tlen && sa.tt > sa.tspan[sa.V_it]) {
-                    memcpy(&sa.V[(ptrdiff_t) sa.Nd *
-                                 (((ptrdiff_t) sa.Ntot * sa.V_it++) +
-                                  sa.Ni)], sa.v_new,
-                           (ptrdiff_t) sa.Nn * (ptrdiff_t) sa.Nd *
-                           sizeof(double));
+                    const ptrdiff_t v_len = (ptrdiff_t) sa.Nn * (ptrdiff_t) sa.Nd *
+                        sizeof(double);
+                    if (v_len > 0) {
+                        memcpy(&sa.V[(ptrdiff_t) sa.Nd *
+                                     (((ptrdiff_t) sa.Ntot * sa.V_it) +
+                                      sa.Ni)],
+                               sa.v_new,
+                               v_len);
+                    }
+                    sa.V_it++;
                 }
 
                 *&model[i] = sa;

src/solvers/SimInf_solver_mssm.c

@@ -288,10 +288,14 @@ SimInf_solver_mssm(
 
                     /* Copy continuous state to V */
                     while (m.V_it < m.tlen && m.tt > m.tspan[m.V_it]) {
-                        memcpy(&m.V[(ptrdiff_t) m.Nd * (ptrdiff_t) m.Ntot *
-                                    m.V_it++], m.v_new,
-                               (ptrdiff_t) m.Nn * (ptrdiff_t) m.Nd *
-                               sizeof(double));
+                        const ptrdiff_t v_len = (ptrdiff_t) m.Nn * (ptrdiff_t) m.Nd *
+                            sizeof(double);
+                        if (v_len > 0) {
+                            memcpy(&m.V[(ptrdiff_t) m.Nd * (ptrdiff_t) m.Ntot * m.V_it],
+                                   m.v_new,
+                                   v_len);
+                        }
+                        m.V_it++;
                     }
 
                     /* Swap the pointers to the continuous state

src/solvers/SimInf_solver_ssm.c

@@ -295,10 +295,14 @@ SimInf_solver_ssm(
 
                 /* Copy continuous state to V */
                 while (m.V && m.V_it < m.tlen && m.tt > m.tspan[m.V_it]) {
-                    memcpy(&m.V[(ptrdiff_t) m.Nd *
-                                ((m.Ntot * m.V_it++) + m.Ni)], m.v_new,
-                           (ptrdiff_t) m.Nn * (ptrdiff_t) m.Nd *
-                           sizeof(double));
+                    const ptrdiff_t v_len = (ptrdiff_t) m.Nn * (ptrdiff_t) m.Nd *
+                        sizeof(double);
+                    if (v_len > 0) {
+                        memcpy(&m.V[(ptrdiff_t) m.Nd * ((m.Ntot * m.V_it) + m.Ni)],
+                               m.v_new,
+                               v_len);
+                    }
+                    m.V_it++;
                 }
 
                 *&model[i] = m;