From 354817f016501c12687e7c6c9239e50e27199425 Mon Sep 17 00:00:00 2001
From: Thibault Hallouin <thibault.hallouin@inrae.fr>
Date: Mon, 29 Aug 2022 10:01:53 +0200
Subject: [PATCH] rename template parameters to C for container

---
 include/evalhyd/evald.hpp     | 18 +++----
 src/determinist/evaluator.hpp | 88 +++++++++++++++++------------------
 2 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/include/evalhyd/evald.hpp b/include/evalhyd/evald.hpp
index 62510f8..feda6c7 100644
--- a/include/evalhyd/evald.hpp
+++ b/include/evalhyd/evald.hpp
@@ -28,7 +28,7 @@ namespace evalhyd
     ///
     /// :Template Parameters:
     ///
-    ///    A: Any inherited class of ``xt::xcontainer<...>``
+    ///    C: Any inherited class of ``xt::xcontainer<...>``
     ///       The type of data structure for the input data (e.g.
     ///       ``xt::xtensor<...>``, ``xt::xarray<...>``).
     ///
@@ -136,15 +136,15 @@ namespace evalhyd
     ///       evalhyd::evald(obs, prd, {"NSE"}, "none", 1, -9, msk);
     ///
     /// \endrst
-    template <class A>
+    template <class C>
     std::vector<xt::xarray<double>> evald(
-            const xt::xexpression<A>& q_obs,
-            const xt::xexpression<A>& q_prd,
+            const xt::xexpression<C>& q_obs,
+            const xt::xexpression<C>& q_prd,
             const std::vector<std::string>& metrics,
             const std::string& transform = "none",
             const double exponent = 1,
             double epsilon = -9,
-            const xt::xexpression<A>& t_msk = A()
+            const xt::xexpression<C>& t_msk = C()
     )
     {
         auto q_obs_ = q_obs.derived_cast();
@@ -153,7 +153,7 @@ namespace evalhyd
 
         // initialise a mask if none provided
         // (corresponding to no temporal subset)
-        A msk;
+        C msk;
         if (t_msk_.size() < 1)
             msk = xt::ones<bool>(q_obs_.shape());
         else
@@ -204,8 +204,8 @@ namespace evalhyd
         }
 
         // apply streamflow transformation if requested
-        A obs;
-        A prd;
+        C obs;
+        C prd;
 
         if ( transform == "none" || (transform == "pow" && exponent == 1))
         {
@@ -266,7 +266,7 @@ namespace evalhyd
         );
 
         // instantiate determinist evaluator
-        eh::determinist::Evaluator<A> evaluator(obs, prd, msk);
+        eh::determinist::Evaluator<C> evaluator(obs, prd, msk);
 
         // declare maps for memoisation purposes
         std::unordered_map<std::string, std::vector<std::string>> elt;
diff --git a/src/determinist/evaluator.hpp b/src/determinist/evaluator.hpp
index 2baaa81..9ff21ff 100644
--- a/src/determinist/evaluator.hpp
+++ b/src/determinist/evaluator.hpp
@@ -23,7 +23,7 @@ namespace evalhyd
 
     namespace determinist
     {
-        template <class A>
+        template <class C>
         class Evaluator
         {
         // define type for function to be used to "mask" (i.e. yield NaNs) the
@@ -34,38 +34,38 @@ namespace evalhyd
                 xt::detail::bitwise_or,
                 xt::xfunction<
                     xt::math::isnan_fun,
-                    const A&
+                    const C&
                 >,
                 xt::xfunction<
                     xt::detail::logical_not,
-                    const A&
+                    const C&
                 >
             >,
             xt::xscalar<float>,
-            const A&
+            const C&
         > nan_function;
 
         private:
             // members for input data
-            const A& _q_obs;
-            const A& _q_prd;
+            const C& _q_obs;
+            const C& _q_prd;
             nan_function q_obs;
             nan_function q_prd;
 
             // members for computational elements
-            A mean_obs;
-            A mean_prd;
-            A quad_err;
-            A quad_obs;
-            A quad_prd;
-            A r_pearson;
-            A bias;
+            C mean_obs;
+            C mean_prd;
+            C quad_err;
+            C quad_obs;
+            C quad_prd;
+            C r_pearson;
+            C bias;
 
         public:
             // constructor method
-            Evaluator(const xt::xexpression<A>& obs,
-                      const xt::xexpression<A>& prd,
-                      const xt::xexpression<A>& msk) :
+            Evaluator(const xt::xexpression<C>& obs,
+                      const xt::xexpression<C>& prd,
+                      const xt::xexpression<C>& msk) :
                     _q_obs{obs.derived_cast()},
                     _q_prd{prd.derived_cast()},
                     // "mask" (i.e. use NaN) observations where predictions are
@@ -87,10 +87,10 @@ namespace evalhyd
             {};
 
             // members for evaluation metrics
-            A RMSE;
-            A NSE;
-            A KGE;
-            A KGEPRIME;
+            C RMSE;
+            C NSE;
+            C KGE;
+            C KGEPRIME;
 
             // methods to compute elements
             void calc_mean_obs();
@@ -116,8 +116,8 @@ namespace evalhyd
         // \assign mean_obs:
         //     Mean observed streamflow.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_mean_obs()
+        template <class C>
+        void Evaluator<C>::calc_mean_obs()
         {
             mean_obs = xt::nanmean(q_obs, -1, xt::keep_dims);
         }
@@ -130,8 +130,8 @@ namespace evalhyd
         // \assign mean_prd:
         //     Mean predicted streamflow.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_mean_prd()
+        template <class C>
+        void Evaluator<C>::calc_mean_prd()
         {
             mean_prd = xt::nanmean(q_prd, -1, xt::keep_dims);
         }
@@ -147,8 +147,8 @@ namespace evalhyd
         // \assign quad_err:
         //     Quadratic errors between observations and predictions.
         //     shape: ({... ,} time)
-        template <class A>
-        void Evaluator<A>::calc_quad_err()
+        template <class C>
+        void Evaluator<C>::calc_quad_err()
         {
             quad_err = xt::square(q_obs - q_prd);
         }
@@ -164,8 +164,8 @@ namespace evalhyd
         // \assign quad_obs:
         //     Quadratic errors between observations and mean observation.
         //     shape: ({... ,} time)
-        template <class A>
-        void Evaluator<A>::calc_quad_obs()
+        template <class C>
+        void Evaluator<C>::calc_quad_obs()
         {
             quad_obs = xt::square(q_obs - mean_obs);
         }
@@ -181,8 +181,8 @@ namespace evalhyd
         // \assign quad_prd:
         //     Quadratic errors between predictions and mean prediction.
         //     shape: ({... ,} time)
-        template <class A>
-        void Evaluator<A>::calc_quad_prd()
+        template <class C>
+        void Evaluator<C>::calc_quad_prd()
         {
             quad_prd = xt::square(q_prd - mean_prd);
         }
@@ -210,8 +210,8 @@ namespace evalhyd
         // \assign r_pearson:
         //     Pearson correlation coefficients.
         //     shape: ({... ,} time)
-        template <class A>
-        void Evaluator<A>::calc_r_pearson()
+        template <class C>
+        void Evaluator<C>::calc_r_pearson()
         {
             // calculate error in timing and dynamics $r_{pearson}$
             // (Pearson's correlation coefficient)
@@ -238,8 +238,8 @@ namespace evalhyd
         // \assign bias:
         //     Biases.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_bias()
+        template <class C>
+        void Evaluator<C>::calc_bias()
         {
             // calculate $bias$
             bias = xt::nansum(q_prd, -1, xt::keep_dims)
@@ -254,8 +254,8 @@ namespace evalhyd
         // \assign RMSE:
         //     Root-mean-square errors.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_RMSE()
+        template <class C>
+        void Evaluator<C>::calc_RMSE()
         {
            // compute RMSE
            RMSE = xt::sqrt(xt::nanmean(quad_err, -1, xt::keep_dims));
@@ -272,12 +272,12 @@ namespace evalhyd
         // \assign NSE:
         //     Nash-Sutcliffe efficiencies.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_NSE()
+        template <class C>
+        void Evaluator<C>::calc_NSE()
         {
             // compute squared errors operands
-            A f_num = xt::nansum(quad_err, -1, xt::keep_dims);
-            A f_den = xt::nansum(quad_obs, -1, xt::keep_dims);
+            C f_num = xt::nansum(quad_err, -1, xt::keep_dims);
+            C f_den = xt::nansum(quad_obs, -1, xt::keep_dims);
 
             // compute NSE
             NSE = 1 - (f_num / f_den);
@@ -306,8 +306,8 @@ namespace evalhyd
         // \assign KGE:
         //     Kling-Gupta efficiencies.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_KGE()
+        template <class C>
+        void Evaluator<C>::calc_KGE()
         {
             // calculate error in spread of flow $alpha$
             auto alpha = detail::std_dev(q_prd, mean_prd)
@@ -344,8 +344,8 @@ namespace evalhyd
         // \assign KGEPRIME:
         //     Modified Kling-Gupta efficiencies.
         //     shape: ({... ,} 1)
-        template <class A>
-        void Evaluator<A>::calc_KGEPRIME()
+        template <class C>
+        void Evaluator<C>::calc_KGEPRIME()
         {
             // calculate error in spread of flow $gamma$
             auto gamma = (detail::std_dev(q_prd, mean_prd) / mean_prd)
-- 
GitLab