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 <memory>
      10              : #include <pup.h>
      11              : 
      12              : #include "Options/String.hpp"
      13              : #include "PointwiseFunctions/MathFunctions/MathFunction.hpp"
      14              : #include "Utilities/Serialization/CharmPupable.hpp"
      15              : #include "Utilities/TMPL.hpp"
      16              : 
      17              : /// \cond
      18              : class DataVector;
      19              : /// \endcond
      20              : 
      21              : namespace MathFunctions {
      22              : template <size_t VolumeDim, typename Fr>
      23            0 : class PowX;
      24              : 
      25              : /*!
      26              :  * \ingroup MathFunctionsGroup
      27              :  * \brief Power of X \f$f(x)=x^X\f$
      28              :  */
      29              : template <typename Fr>
      30            1 : class PowX<1, Fr> : public MathFunction<1, Fr> {
      31              :  public:
      32            0 :   struct Power {
      33            0 :     using type = int;
      34            0 :     static constexpr Options::String help = {
      35              :         "The power that the double is raised to."};
      36              :   };
      37            0 :   using options = tmpl::list<Power>;
      38              : 
      39            0 :   static constexpr Options::String help = {
      40              :       "Raises the input value to a given power"};
      41            0 :   PowX() = default;
      42              : 
      43            0 :   WRAPPED_PUPable_decl_base_template(SINGLE_ARG(MathFunction<1, Fr>),
      44              :                                      PowX);  // NOLINT
      45            0 :   std::unique_ptr<MathFunction<1, Fr>> get_clone() const override;
      46              : 
      47            0 :   explicit PowX(int power);
      48              : 
      49            0 :   explicit PowX(CkMigrateMessage* /*unused*/) {}
      50              : 
      51            1 :   double operator()(const double& x) const override;
      52            0 :   DataVector operator()(const DataVector& x) const override;
      53              : 
      54            1 :   double first_deriv(const double& x) const override;
      55            0 :   DataVector first_deriv(const DataVector& x) const override;
      56              : 
      57            1 :   double second_deriv(const double& x) const override;
      58            0 :   DataVector second_deriv(const DataVector& x) const override;
      59              : 
      60            1 :   double third_deriv(const double& x) const override;
      61            0 :   DataVector third_deriv(const DataVector& x) const override;
      62              : 
      63            0 :   bool operator==(const MathFunction<1, Fr>& other) const override;
      64            0 :   bool operator!=(const MathFunction<1, Fr>& other) const override;
      65              : 
      66            0 :   bool operator==(const PowX<1, Fr>& other) const;
      67            0 :   bool operator!=(const PowX<1, Fr>& other) const;
      68              : 
      69              :   // NOLINTNEXTLINE(google-runtime-references)
      70            0 :   void pup(PUP::er& p) override;
      71              : 
      72              :  private:
      73            0 :   double power_{};
      74              : 
      75              :   template <typename T>
      76            0 :   T apply_call_operator(const T& x) const;
      77              :   template <typename T>
      78            0 :   T apply_first_deriv(const T& x) const;
      79              :   template <typename T>
      80            0 :   T apply_second_deriv(const T& x) const;
      81              :   template <typename T>
      82            0 :   T apply_third_deriv(const T& x) const;
      83              : };
      84              : 
      85              : }  // namespace MathFunctions
      86              : 
      87              : /// \cond
      88              : template <typename Fr>
      89              : PUP::able::PUP_ID MathFunctions::PowX<1, Fr>::my_PUP_ID = 0;  // NOLINT
      90              : /// \endcond