symengine_math.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_differentiation_sd_symengine_math_h
#define dealii_differentiation_sd_symengine_math_h

#include <deal.II/base/config.h>

#ifdef DEAL_II_WITH_SYMENGINE

#  include <deal.II/differentiation/sd/symengine_number_types.h>

#  include <type_traits>

DEAL_II_NAMESPACE_OPEN

namespace Differentiation
{
  namespace SD
  {
    // Mathematical functions:
    //
    // It is necessary that all computed inputs to SymEngine functions are
    // of type SymEngine::RCP<SymEngine::Basic>. So we instead simply offer a
    // unified interface to Expression types and with other permutations of
    // numbers we convert between them.
    //
    // For a full list of functions that we (ultimately) expect to support, see
    // http://www.cplusplus.com/reference/cmath/. Those that are currently
    // supported are extracted from symengine/{functions,pow}.h;
    // symengine/type_codes.inc.



    Expression
    pow(const Expression &base, const Expression &exponent);

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    pow(const Expression &base, const NumberType &exponent)
    {
      // Call other implementation
      return pow(base, Expression(exponent));
    }

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    pow(const NumberType &base, const Expression &exponent)
    {
      // Call other implementation
      return pow(Expression(base), exponent);
    }

    Expression
    sqrt(const Expression &x);

    Expression
    cbrt(const Expression &x);

    Expression
    exp(const Expression &exponent);

    Expression
    log(const Expression &x);

    Expression
    log(const Expression &x, const Expression &base);

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    log(const Expression &x, const NumberType &base)
    {
      // Call other implementation
      return log(x, Expression(base));
    }

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    log(const NumberType &x, const Expression &base)
    {
      // Call other implementation
      return log(Expression(x), base);
    }

    Expression
    log10(const Expression &x);



    Expression
    sin(const Expression &x);

    Expression
    cos(const Expression &x);

    Expression
    tan(const Expression &x);

    Expression
    csc(const Expression &x);

    Expression
    sec(const Expression &x);

    Expression
    cot(const Expression &x);

    Expression
    asin(const Expression &x);

    Expression
    acos(const Expression &x);

    Expression
    atan(const Expression &x);

    Expression
    atan2(const Expression &y, const Expression &x);

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    atan2(const NumberType &y, const Expression &x)
    {
      // Call other implementation
      return atan2(Expression(y), x);
    }

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    atan2(const Expression &y, const NumberType &x)
    {
      // Call other implementation
      return atan2(y, Expression(x));
    }

    Expression
    acsc(const Expression &x);

    Expression
    asec(const Expression &x);

    Expression
    acot(const Expression &x);



    Expression
    sinh(const Expression &x);

    Expression
    cosh(const Expression &x);

    Expression
    tanh(const Expression &x);

    Expression
    csch(const Expression &x);

    Expression
    sech(const Expression &x);

    Expression
    coth(const Expression &x);

    Expression
    asinh(const Expression &x);

    Expression
    acosh(const Expression &x);

    Expression
    atanh(const Expression &x);

    Expression
    acsch(const Expression &x);

    Expression
    asech(const Expression &x);

    Expression
    acoth(const Expression &x);



    Expression
    abs(const Expression &x);


    Expression
    fabs(const Expression &x);


    Expression
    sign(const Expression &x);


    Expression
    copysign(const Expression &value, const Expression &sign);


    Expression
    floor(const Expression &x);


    Expression
    ceil(const Expression &x);

    Expression
    max(const Expression &a, const Expression &b);

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    max(const Expression &a, const NumberType &b)
    {
      // Call other implementation
      return max(a, Expression(b));
    }

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    max(const NumberType &a, const Expression &b)
    {
      // Call other implementation
      return max(Expression(a), b);
    }

    Expression
    min(const Expression &a, const Expression &b);

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    min(const Expression &a, const NumberType &b)
    {
      // Call other implementation
      return min(a, Expression(b));
    }

    template <typename NumberType,
              typename = typename std::enable_if<
                !std::is_same<NumberType, Expression>::value>::type>
    Expression
    min(const NumberType &a, const Expression &b)
    {
      // Call other implementation
      return min(Expression(a), b);
    }

    Expression
    erf(const Expression &x);

    Expression
    erfc(const Expression &x);


  } // namespace SD
} // namespace Differentiation

DEAL_II_NAMESPACE_CLOSE


#  ifndef DOXYGEN

// Import math operations into standard namespace.
// This gives us the ability to use them within the Tensor class.
namespace std
{
#    define DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(func) \
      using ::Differentiation::SD::func;

#    define DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION(func) \
      using ::Differentiation::SD::func;

  DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION(pow)
  DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION(max)
  DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION(min)
  DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION(copysign)

  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(exp)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(log10)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(sqrt)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(cbrt)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(erf)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(erfc)
  // Note: Both unary and binary versions
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(log)

  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(abs)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(fabs)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(sign)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(floor)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(ceil)

  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(sin)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(cos)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(tan)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(csc)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(sec)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(cot)

  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(asin)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(acos)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(atan)
  DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION(atan2)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(acsc)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(asec)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(acot)

  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(sinh)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(cosh)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(tanh)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(csch)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(sech)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(coth)

  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(asinh)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(acosh)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(atanh)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(acsch)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(asech)
  DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION(acoth)

#    undef DEAL_II_EXPOSE_SYMENGINE_BINARY_MATH_FUNCTION
#    undef DEAL_II_EXPOSE_SYMENGINE_UNARY_MATH_FUNCTION

} // namespace std

#  endif // DOXYGEN

#endif // DEAL_II_WITH_SYMENGINE

#endif