From cb812c742c25e2737808cf7ec349e4eeffb0d911 Mon Sep 17 00:00:00 2001 From: Tomasz Sobczyk Date: Sun, 29 Nov 2020 22:52:21 +0100 Subject: [PATCH] Add [[nodiscard]] attributes to autograd functions. --- src/learn/autograd.h | 80 ++++++++++++++++++++++---------------------- 1 file changed, 40 insertions(+), 40 deletions(-) diff --git a/src/learn/autograd.h b/src/learn/autograd.h index 4edf0e4c..5c573c0f 100644 --- a/src/learn/autograd.h +++ b/src/learn/autograd.h @@ -45,12 +45,12 @@ namespace Learner return *this; } - ValueWithGrad abs() const + [[nodiscard]] ValueWithGrad abs() const { return { std::abs(value), std::abs(grad) }; } - ValueWithGrad clamp_grad(T max) const + [[nodiscard]] ValueWithGrad clamp_grad(T max) const { return { value, std::clamp(grad, -max, max) }; } @@ -82,13 +82,13 @@ namespace Learner::Autograd::UnivariateStatic constexpr Evaluable() = default; template - auto eval(const std::tuple& args) const + [[nodiscard]] auto eval(const std::tuple& args) const { return ValueWithGrad{ value(args), grad(args) }; } template - auto value(const std::tuple& args) const + [[nodiscard]] auto value(const std::tuple& args) const { const ChildT* this_ = static_cast(this); @@ -101,7 +101,7 @@ namespace Learner::Autograd::UnivariateStatic } template - auto grad(const std::tuple& args) const + [[nodiscard]] auto grad(const std::tuple& args) const { const ChildT* this_ = static_cast(this); @@ -128,13 +128,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return std::get(args); } template - T calculate_grad(const std::tuple&) const + [[nodiscard]] T calculate_grad(const std::tuple&) const { return T(1.0); } @@ -150,13 +150,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return std::get(args); } template - T calculate_grad(const std::tuple&) const + [[nodiscard]] T calculate_grad(const std::tuple&) const { return T(0.0); } @@ -173,13 +173,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple&) const + [[nodiscard]] T calculate_value(const std::tuple&) const { return m_x; } template - T calculate_grad(const std::tuple&) const + [[nodiscard]] T calculate_grad(const std::tuple&) const { return T(0.0); } @@ -200,13 +200,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return m_lhs.value(args) + m_rhs.value(args); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return m_lhs.grad(args) + m_rhs.grad(args); } @@ -217,19 +217,19 @@ namespace Learner::Autograd::UnivariateStatic }; template ::ValueType> - constexpr auto operator+(LhsT&& lhs, RhsT&& rhs) + [[nodiscard]] constexpr auto operator+(LhsT&& lhs, RhsT&& rhs) { return Sum(std::forward(lhs), std::forward(rhs)); } template ::ValueType> - constexpr auto operator+(LhsT&& lhs, Id rhs) + [[nodiscard]] constexpr auto operator+(LhsT&& lhs, Id rhs) { return Sum&&>(std::forward(lhs), Constant(rhs)); } template ::ValueType> - constexpr auto operator+(Id lhs, RhsT&& rhs) + [[nodiscard]] constexpr auto operator+(Id lhs, RhsT&& rhs) { return Sum&&, RhsT&&>(Constant(lhs), std::forward(rhs)); } @@ -246,13 +246,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return m_lhs.value(args) - m_rhs.value(args); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return m_lhs.grad(args) - m_rhs.grad(args); } @@ -263,19 +263,19 @@ namespace Learner::Autograd::UnivariateStatic }; template ::ValueType> - constexpr auto operator-(LhsT&& lhs, RhsT&& rhs) + [[nodiscard]] constexpr auto operator-(LhsT&& lhs, RhsT&& rhs) { return Difference(std::forward(lhs), std::forward(rhs)); } template ::ValueType> - constexpr auto operator-(LhsT&& lhs, Id rhs) + [[nodiscard]] constexpr auto operator-(LhsT&& lhs, Id rhs) { return Difference&&>(std::forward(lhs), Constant(rhs)); } template ::ValueType> - constexpr auto operator-(Id lhs, RhsT&& rhs) + [[nodiscard]] constexpr auto operator-(Id lhs, RhsT&& rhs) { return Difference&&, RhsT&&>(Constant(lhs), std::forward(rhs)); } @@ -292,13 +292,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return m_lhs.value(args) * m_rhs.value(args); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return m_lhs.grad(args) * m_rhs.value(args) + m_lhs.value(args) * m_rhs.grad(args); } @@ -309,19 +309,19 @@ namespace Learner::Autograd::UnivariateStatic }; template ::ValueType> - constexpr auto operator*(LhsT&& lhs, RhsT&& rhs) + [[nodiscard]] constexpr auto operator*(LhsT&& lhs, RhsT&& rhs) { return Product(std::forward(lhs), std::forward(rhs)); } template ::ValueType> - constexpr auto operator*(LhsT&& lhs, Id rhs) + [[nodiscard]] constexpr auto operator*(LhsT&& lhs, Id rhs) { return Product&&>(std::forward(lhs), Constant(rhs)); } template ::ValueType> - constexpr auto operator*(Id lhs, RhsT&& rhs) + [[nodiscard]] constexpr auto operator*(Id lhs, RhsT&& rhs) { return Product&&, RhsT&&>(Constant(lhs), std::forward(rhs)); } @@ -337,13 +337,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return -m_x.value(args); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return -m_x.grad(args); } @@ -353,7 +353,7 @@ namespace Learner::Autograd::UnivariateStatic }; template ::ValueType> - constexpr auto operator-(ArgT&& x) + [[nodiscard]] constexpr auto operator-(ArgT&& x) { return Negation(std::forward(x)); } @@ -369,13 +369,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return value_(m_x.value(args)); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return m_x.grad(args) * grad_(m_x.value(args)); } @@ -383,19 +383,19 @@ namespace Learner::Autograd::UnivariateStatic private: StoreValueOrRef m_x; - T value_(T x) const + [[nodiscard]] T value_(T x) const { return 1.0 / (1.0 + std::exp(-x)); } - T grad_(T x) const + [[nodiscard]] T grad_(T x) const { return value_(x) * (1.0 - value_(x)); } }; template ::ValueType> - constexpr auto sigmoid(ArgT&& x) + [[nodiscard]] constexpr auto sigmoid(ArgT&& x) { return Sigmoid(std::forward(x)); } @@ -412,13 +412,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return std::pow(m_x.value(args), m_exponent); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return m_exponent * std::pow(m_x.value(args), m_exponent - T(1.0)) * m_x.grad(args); } @@ -429,7 +429,7 @@ namespace Learner::Autograd::UnivariateStatic }; template ::ValueType> - constexpr auto pow(ArgT&& x, Id exp) + [[nodiscard]] constexpr auto pow(ArgT&& x, Id exp) { return Pow(std::forward(x), std::move(exp)); } @@ -445,13 +445,13 @@ namespace Learner::Autograd::UnivariateStatic } template - T calculate_value(const std::tuple& args) const + [[nodiscard]] T calculate_value(const std::tuple& args) const { return value_(m_x.value(args)); } template - T calculate_grad(const std::tuple& args) const + [[nodiscard]] T calculate_grad(const std::tuple& args) const { return m_x.grad(args) * grad_(m_x.value(args)); } @@ -471,7 +471,7 @@ namespace Learner::Autograd::UnivariateStatic }; template ::ValueType> - constexpr auto log(ArgT&& x) + [[nodiscard]] constexpr auto log(ArgT&& x) { return Log(std::forward(x)); }