SpECTRE Documentation Coverage Report
Current view: top level - PointwiseFunctions/MathFunctions - PowX.hpp Hit Total Coverage
Commit: 2ae2b99409ac582030d56a4560a92a3e066a7e54 Lines: 6 33 18.2 %
Date: 2022-01-15 08:40:38
Legend: Lines: hit not hit

          Line data    Source code
       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines MathFunctions::PowX.
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <pup.h>
      10             : 
      11             : #include "Options/Options.hpp"
      12             : #include "Parallel/CharmPupable.hpp"
      13             : #include "PointwiseFunctions/MathFunctions/MathFunction.hpp"  // IWYU pragma: keep
      14             : #include "Utilities/TMPL.hpp"
      15             : 
      16             : /// \cond
      17             : class DataVector;
      18             : /// \endcond
      19             : 
      20             : namespace MathFunctions {
      21             : template <size_t VolumeDim, typename Fr>
      22           0 : class PowX;
      23             : 
      24             : /*!
      25             :  * \ingroup MathFunctionsGroup
      26             :  * \brief Power of X \f$f(x)=x^X\f$
      27             :  */
      28             : template <typename Fr>
      29           1 : class PowX<1, Fr> : public MathFunction<1, Fr> {
      30             :  public:
      31           0 :   struct Power {
      32           0 :     using type = int;
      33           0 :     static constexpr Options::String help = {
      34             :         "The power that the double is raised to."};
      35             :   };
      36           0 :   using options = tmpl::list<Power>;
      37             : 
      38           0 :   static constexpr Options::String help = {
      39             :       "Raises the input value to a given power"};
      40             : 
      41           0 :   PowX() = default;
      42           0 :   ~PowX() override = default;
      43           0 :   PowX(const PowX& /*rhs*/) = delete;
      44           0 :   PowX& operator=(const PowX& /*rhs*/) = delete;
      45           0 :   PowX(PowX&& /*rhs*/) = default;
      46           0 :   PowX& operator=(PowX&& /*rhs*/) = default;
      47             : 
      48           0 :   WRAPPED_PUPable_decl_base_template(SINGLE_ARG(MathFunction<1, Fr>),
      49             :                                      PowX);  // NOLINT
      50             : 
      51           0 :   explicit PowX(int power);
      52             : 
      53           0 :   explicit PowX(CkMigrateMessage* /*unused*/) {}
      54             : 
      55           1 :   double operator()(const double& x) const override;
      56           0 :   DataVector operator()(const DataVector& x) const override;
      57             : 
      58           1 :   double first_deriv(const double& x) const override;
      59           0 :   DataVector first_deriv(const DataVector& x) const override;
      60             : 
      61           1 :   double second_deriv(const double& x) const override;
      62           0 :   DataVector second_deriv(const DataVector& x) const override;
      63             : 
      64           1 :   double third_deriv(const double& x) const override;
      65           0 :   DataVector third_deriv(const DataVector& x) const override;
      66             : 
      67             :   // NOLINTNEXTLINE(google-runtime-references)
      68           0 :   void pup(PUP::er& p) override;
      69             : 
      70             :  private:
      71           0 :   double power_{};
      72           0 :   friend bool operator==(const PowX& lhs, const PowX& rhs) {
      73             :     return lhs.power_ == rhs.power_;
      74             :   }
      75             : 
      76             :   template <typename T>
      77           0 :   T apply_call_operator(const T& x) const;
      78             :   template <typename T>
      79           0 :   T apply_first_deriv(const T& x) const;
      80             :   template <typename T>
      81           0 :   T apply_second_deriv(const T& x) const;
      82             :   template <typename T>
      83           0 :   T apply_third_deriv(const T& x) const;
      84             : };
      85             : 
      86             : template <typename Fr>
      87           0 : bool operator!=(const PowX<1, Fr>& lhs, const PowX<1, Fr>& rhs) {
      88             :   return not(lhs == rhs);
      89             : }
      90             : }  // namespace MathFunctions
      91             : 
      92             : /// \cond
      93             : template <typename Fr>
      94             : PUP::able::PUP_ID MathFunctions::PowX<1, Fr>::my_PUP_ID = 0;  // NOLINT
      95             : /// \endcond

Generated by: LCOV version 1.14