Release 0.11.21

Merge pull request #1596 from AMICI-dev/release/0.11.21

Author: dweindl

.gitignore

@@ -154,6 +154,7 @@ python/examples/example_presimulation/model_presimulation_re/*
 python/examples/example_constant_species/model_constant_species_reduced/*
 python/examples/example_constant_species/model_constant_species/*
 python/tests/sbml_test_models/*
+python/tests/piecewise_test/*
 
 python/sdist/amici.egg-info/*
 python/sdist/amici/version.txt

CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## v0.X Series
 
+### v0.11.21 (2021-11-21)
+
+Fixes:
+ * Fixed a bug in recursion depth computation for model expressions. This may
+   have resulted in incorrect sensitivities for models with expressions nested
+   more than 2 levels. (#1595)
+ * Fixed improper handling of Piecewise functions in PySB import which may have
+   produced incorrect simulation results. (#1594)
+ * Fixed changed googletest reference which broke the CMake-based build if
+   tests were enabled (#1592)
+
+New:
+ * It's now possible to build AMICI using Ninja (#1593)
+
+
 ### v0.11.20 (2021-11-12)
 
 New: 

include/amici/sundials_matrix_wrapper.h

@@ -325,6 +325,17 @@ class SUNMatrixWrapper {
      */
     void multiply(N_Vector c, const_N_Vector b, realtype alpha = 1.0) const;
 
+    /**
+     * @brief AmiVector interface for multiply
+     * @param c output vector, may already contain values
+     * @param b multiplication vector
+     * @param alpha scalar coefficient for matrix
+     */
+    void multiply(AmiVector& c, AmiVector const& b, realtype alpha = 1.0) const {
+        multiply(c.getNVector(), b.getNVector(), alpha);
+    }
+
+
     /**
      * @brief Perform matrix vector multiplication c += alpha * A*b
      * @param c output vector, may already contain values

include/amici/vector.h

@@ -86,6 +86,44 @@ class AmiVector {
      */
     AmiVector &operator=(AmiVector const &other);
 
+    /**
+     * @brief operator *= (element-wise multiplication)
+     * @param multiplier multiplier
+     * @return result
+     */
+    AmiVector &operator*=(AmiVector const& multiplier) {
+        N_VProd(getNVector(),
+               const_cast<N_Vector>(multiplier.getNVector()),
+               getNVector());
+        return *this;
+    }
+
+    /**
+     * @brief operator /= (element-wise division)
+     * @param divisor divisor
+     * @return result
+     */
+    AmiVector &operator/=(AmiVector const& divisor) {
+        N_VDiv(getNVector(),
+               const_cast<N_Vector>(divisor.getNVector()),
+               getNVector());
+        return *this;
+    }
+
+    /**
+     * @brief Returns an iterator that points to the first element of the
+     * vector.
+     * @return iterator that points to the first element
+     */
+    auto begin() { return vec_.begin(); }
+
+    /**
+     * @brief Returns an iterator that points to one element after the last
+     * element of the vector.
+     * @return iterator that points to one element after the last element
+     */
+    auto end() { return vec_.end(); }
+
     /**
      * @brief data accessor
      * @return pointer to data array
@@ -164,6 +202,13 @@ class AmiVector {
      */
     void copy(const AmiVector &other);
 
+    /**
+     * @brief Take absolute value (in-place)
+     */
+    void abs() {
+        N_VAbs(getNVector(), getNVector());
+    };
+
   private:
     /** main data storage */
     std::vector<realtype> vec_;
@@ -315,6 +360,32 @@ class AmiVectorArray {
     std::vector<N_Vector> nvec_array_;
 };
 
+/**
+ * @brief Computes z = a*x + b*y
+ * @param a coefficient for x
+ * @param x a vector
+ * @param b coefficient for y
+ * @param y another vector with same size as x
+ * @param z result vector of same size as x and y
+ */
+inline void linearSum(realtype a, AmiVector const& x, realtype b,
+               AmiVector const& y, AmiVector& z) {
+    N_VLinearSum(a, const_cast<N_Vector>(x.getNVector()),
+                 b, const_cast<N_Vector>(y.getNVector()),
+                 z.getNVector());
+}
+
+/**
+ * @brief Compute dot product of x and y
+ * @param x vector
+ * @param y vector
+ * @return dot product of x and y
+ */
+inline realtype dotProd(AmiVector const& x, AmiVector const& y) {
+    return N_VDotProd(const_cast<N_Vector>(x.getNVector()),
+                      const_cast<N_Vector>(y.getNVector()));
+}
+
 } // namespace amici