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