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