boost/math
2
0
Fork 0
mirror of https://github.com/boostorg/math.git synced 2026-01-19 04:22:09 +00:00
Code Issues Projects Releases Wiki Activity

added ability to turn off ets with a macro

Browse Source
This commit is contained in:
mzhelyez
2025-08-25 09:40:20 +02:00
parent d95fe1675d
commit afc6577e6c
8 changed files with 882 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
include/boost/math/differentiation/autodiff_reverse.hpp
View File

@@ -6,12 +6,23 @@
#define BOOST_MATH_DIFFERENTIATION_AUTODIFF_HPP
#include <boost/math/constants/constants.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp>
#ifndef BOOST_MATH_ET_OFF
#define BOOST_MATH_ET_ON
#endif
#ifdef BOOST_MATH_ET_ON
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp>
#else
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp>
#endif
#include <boost/math/differentiation/detail/reverse_mode_autodiff_comparison_operator_overloads.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_memory_management.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp>
#include <boost/math/special_functions/acosh.hpp>
#include <boost/math/special_functions/asinh.hpp>
#include <boost/math/special_functions/atanh.hpp>

142
include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp → include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp
View File

@@ -268,148 +268,6 @@ struct const_div_by_expr
};
/****************************************************************************************************************/
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
mult_expr<RealType, DerivativeOrder, LHS, RHS> operator*(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
/** @brief type promotion is handled by casting the numeric type to
* the type inside expression. This is to avoid converting the
* entire tape in case you have something like double * rvar<float>
* */
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
/****************************************************************************************************************/
/* + */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
add_expr<RealType, DerivativeOrder, LHS, RHS> operator+(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
/****************************************************************************************************************/
/* - overload */
/** @brief
* negation (-1.0*rvar) */
template<typename RealType, size_t DerivativeOrder, typename ARG>
mult_const_expr<RealType, DerivativeOrder, ARG> operator-(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
}
/** @brief
* subtraction rvar-rvar */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
sub_expr<RealType, DerivativeOrder, LHS, RHS> operator-(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
/** @brief
* subtraction float - rvar */
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
add_const_expr<RealType1, DerivativeOrder, ARG> operator-(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
/* rvar - float = rvar + (-float) */
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
}
/** @brief
* subtraction float - rvar
* @return add_expr<neg_expr<ARG>>
*/
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
auto operator-(const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
auto neg = -arg;
return neg + static_cast<RealType1>(v);
}
/****************************************************************************************************************/
/* / */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
div_expr<RealType, DerivativeOrder, LHS, RHS> operator/(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
const_div_by_expr<RealType1, DerivativeOrder, ARG> operator/(
const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
div_by_const_expr<RealType1, DerivativeOrder, ARG> operator/(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
} // namespace reverse_mode
} // namespace differentiation
} // namespace math

160
include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp Normal file
View File

@@ -0,0 +1,160 @@
// Copyright Maksym Zhelyenzyakov 2025-2026.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#ifndef REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
#define REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp>
namespace boost {
namespace math {
namespace differentiation {
namespace reverse_mode {
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
mult_expr<RealType, DerivativeOrder, LHS, RHS> operator*(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
/** @brief type promotion is handled by casting the numeric type to
* the type inside expression. This is to avoid converting the
* entire tape in case you have something like double * rvar<float>
* */
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
/****************************************************************************************************************/
/* + */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
add_expr<RealType, DerivativeOrder, LHS, RHS> operator+(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
/****************************************************************************************************************/
/* - overload */
/** @brief
* negation (-1.0*rvar) */
template<typename RealType, size_t DerivativeOrder, typename ARG>
mult_const_expr<RealType, DerivativeOrder, ARG> operator-(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
}
/** @brief
* subtraction rvar-rvar */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
sub_expr<RealType, DerivativeOrder, LHS, RHS> operator-(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
/** @brief
* subtraction float - rvar */
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
add_const_expr<RealType1, DerivativeOrder, ARG> operator-(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
/* rvar - float = rvar + (-float) */
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
}
/** @brief
* subtraction float - rvar
* @return add_expr<neg_expr<ARG>>
*/
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
auto operator-(const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
auto neg = -arg;
return neg + static_cast<RealType1>(v);
}
/****************************************************************************************************************/
/* / */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
div_expr<RealType, DerivativeOrder, LHS, RHS> operator/(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
const_div_by_expr<RealType1, DerivativeOrder, ARG> operator/(
const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
div_by_const_expr<RealType1, DerivativeOrder, ARG> operator/(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
} // namespace reverse_mode
} // namespace differentiation
} // namespace math
} // namespace boost
#endif // REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP

154
include/boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp Normal file
View File

@@ -0,0 +1,154 @@
// Copyright Maksym Zhelyenzyakov 2025-2026.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#ifndef REVERSE_MODE_AUTODIFF_BASIC_OPS_NO_ET_HPP
#define REVERSE_MODE_AUTODIFF_BASIC_OPS_NO_ET_HPP
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp>
namespace boost {
namespace math {
namespace differentiation {
namespace reverse_mode {
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
rvar<RealType, DerivativeOrder> operator*(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
/** @brief type promotion is handled by casting the numeric type to
* the type inside expression. This is to avoid converting the
* entire tape in case you have something like double * rvar<float>
* */
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator*(const expression<RealType1, DerivativeOrder, ARG> &arg,
const RealType2 &v)
{
return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator*(const RealType2 &v,
const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
/****************************************************************************************************************/
/* + */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
rvar<RealType, DerivativeOrder> operator+(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator+(const expression<RealType1, DerivativeOrder, ARG> &arg,
const RealType2 &v)
{
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator+(const RealType2 &v,
const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
/****************************************************************************************************************/
/* - overload */
/** @brief
* negation (-1.0*rvar) */
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> operator-(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
}
/** @brief
* subtraction rvar-rvar */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
rvar<RealType, DerivativeOrder> operator-(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
/** @brief
* subtraction float - rvar */
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator-(const expression<RealType1, DerivativeOrder, ARG> &arg,
const RealType2 &v)
{
/* rvar - float = rvar + (-float) */
return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
}
/** @brief
* subtraction float - rvar
* @return add_expr<neg_expr<ARG>>
*/
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator-(const RealType2 &v,
const expression<RealType1, DerivativeOrder, ARG> &arg)
{
auto neg = -arg;
return neg + static_cast<RealType1>(v);
}
/****************************************************************************************************************/
/* / */
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
rvar<RealType, DerivativeOrder> operator/(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator/(const RealType2 &v,
const expression<RealType1, DerivativeOrder, ARG> &arg)
{
return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> operator/(const expression<RealType1, DerivativeOrder, ARG> &arg,
const RealType2 &v)
{
return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
}
} // namespace reverse_mode
} // namespace differentiation
} // namespace math
} // namespace boost
#endif

8
include/boost/math/differentiation/detail/reverse_mode_autodiff_erf_overloads.hpp
View File

@@ -7,7 +7,13 @@
#include <boost/math/constants/constants.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp>
#ifdef BOOST_MATH_ET_ON
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp>
#else
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp>
#endif
#include <boost/math/differentiation/detail/reverse_mode_autodiff_utilities.hpp>
#include <boost/math/special_functions/erf.hpp>
#include <boost/multiprecision/cpp_bin_float.hpp>

275
include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_et.hpp Normal file
View File

@@ -0,0 +1,275 @@
// Copyright Maksym Zhelyenzyakov 2025-2026.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#ifndef REVERSE_MODE_AUTODIFF_STL_ET_HPP
#define REVERSE_MODE_AUTODIFF_STL_ET_HPP
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp>
namespace boost {
namespace math {
namespace differentiation {
namespace reverse_mode {
template<typename RealType, size_t DerivativeOrder, typename ARG>
fabs_expr<RealType, DerivativeOrder, ARG> fabs(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto abs(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return fabs(arg);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
ceil_expr<RealType, DerivativeOrder, ARG> ceil(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
floor_expr<RealType, DerivativeOrder, ARG> floor(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
exp_expr<RealType, DerivativeOrder, ARG> exp(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
pow_expr<RealType, DerivativeOrder, LHS, RHS> pow(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
expr_pow_float_expr<RealType1, DerivativeOrder, ARG> pow(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
float_pow_expr_expr<RealType, DerivativeOrder, ARG> pow(
const RealType &v, const expression<RealType, DerivativeOrder, ARG> &arg)
{
return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
log_expr<RealType, DerivativeOrder, ARG> log(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
sqrt_expr<RealType, DerivativeOrder, ARG> sqrt(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
{
BOOST_MATH_STD_USING
frexp(arg.evaluate(), i);
return arg / pow(static_cast<RealType>(2.0), *i);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
{
BOOST_MATH_STD_USING
return arg * pow(static_cast<RealType>(2.0), i);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
cos_expr<RealType, DerivativeOrder, ARG> cos(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
sin_expr<RealType, DerivativeOrder, ARG> sin(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
tan_expr<RealType, DerivativeOrder, ARG> tan(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
acos_expr<RealType, DerivativeOrder, ARG> acos(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
asin_expr<RealType, DerivativeOrder, ARG> asin(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
atan_expr<RealType, DerivativeOrder, ARG> atan(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
atan2_expr<RealType, DerivativeOrder, LHS, RHS> atan2(
const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
atan2_right_float_expr<RealType, DerivativeOrder, ARG> atan2(
const expression<RealType, DerivativeOrder, ARG> &arg, const RealType &v)
{
return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
atan2_left_float_expr<RealType, DerivativeOrder, ARG> atan2(
const RealType &v, const expression<RealType, DerivativeOrder, ARG> &arg)
{
return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
trunc_expr<RealType, DerivativeOrder, ARG> trunc(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
{
return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
{
return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
round_expr<RealType, DerivativeOrder, ARG> round(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return iround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
BOOST_MATH_STD_USING
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return lround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return llround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return itrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return ltrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return lltrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
sinh_expr<RealType, DerivativeOrder, ARG> sinh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
cosh_expr<RealType, DerivativeOrder, ARG> cosh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
tanh_expr<RealType, DerivativeOrder, ARG> tanh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
log10_expr<RealType, DerivativeOrder, ARG> log10(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
asinh_expr<RealType, DerivativeOrder, ARG> asinh(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
acosh_expr<RealType, DerivativeOrder, ARG> acosh(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
atanh_expr<RealType, DerivativeOrder, ARG> atanh(
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
} // namespace reverse_mode
} // namespace differentiation
} // namespace math
} // namespace boost
#endif

250
include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_overloads.hpp → include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp
View File

@@ -5,7 +5,13 @@
#ifndef REVERSE_MODE_AUTODIFF_STL_OVERLOADS
#define REVERSE_MODE_AUTODIFF_STL_OVERLOADS
/* stl support : expressions */
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_overloads.hpp>
#ifdef BOOST_MATH_ET_ON
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_et.hpp>
#else
#include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_ops_no_et.hpp>
#endif
#include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
#include <boost/math/special_functions/round.hpp>
#include <boost/math/special_functions/trunc.hpp>
@@ -836,249 +842,7 @@ struct fmod_right_float_expr
}
};
/**************************************************************************************************/
template<typename RealType, size_t DerivativeOrder, typename ARG>
fabs_expr<RealType, DerivativeOrder, ARG> fabs(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto abs(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return fabs(arg);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
ceil_expr<RealType, DerivativeOrder, ARG> ceil(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
floor_expr<RealType, DerivativeOrder, ARG> floor(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
exp_expr<RealType, DerivativeOrder, ARG> exp(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
pow_expr<RealType, DerivativeOrder, LHS, RHS> pow(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
expr_pow_float_expr<RealType1, DerivativeOrder, ARG> pow(
const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
{
return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
float_pow_expr_expr<RealType, DerivativeOrder, ARG> pow(const RealType &v, const expression<RealType,DerivativeOrder, ARG> &arg)
{
return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
log_expr<RealType, DerivativeOrder, ARG> log(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
sqrt_expr<RealType, DerivativeOrder, ARG> sqrt(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
{
BOOST_MATH_STD_USING
frexp(arg.evaluate(), i);
return arg / pow(static_cast<RealType>(2.0), *i);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
{
BOOST_MATH_STD_USING
return arg * pow(static_cast<RealType>(2.0), i);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
cos_expr<RealType, DerivativeOrder, ARG> cos(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
sin_expr<RealType, DerivativeOrder, ARG> sin(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
tan_expr<RealType, DerivativeOrder, ARG> tan(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
acos_expr<RealType, DerivativeOrder, ARG> acos(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
asin_expr<RealType, DerivativeOrder, ARG> asin(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
atan_expr<RealType, DerivativeOrder, ARG> atan(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
atan2_expr<RealType, DerivativeOrder, LHS, RHS> atan2(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
atan2_right_float_expr<RealType, DerivativeOrder, ARG> atan2(const expression<RealType,DerivativeOrder, ARG> &arg, const RealType &v)
{
return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
atan2_left_float_expr<RealType, DerivativeOrder, ARG> atan2(const RealType &v, const expression<RealType,DerivativeOrder, ARG> &arg)
{
return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
trunc_expr<RealType, DerivativeOrder, ARG> trunc(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs, const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
{
return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
{
return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
round_expr<RealType, DerivativeOrder, ARG> round(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return iround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
BOOST_MATH_STD_USING
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return lround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return llround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return itrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return ltrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return lltrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
sinh_expr<RealType, DerivativeOrder, ARG> sinh(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
cosh_expr<RealType, DerivativeOrder, ARG> cosh(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
tanh_expr<RealType, DerivativeOrder, ARG> tanh(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
log10_expr<RealType, DerivativeOrder, ARG> log10(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
asinh_expr<RealType, DerivativeOrder, ARG> asinh(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
acosh_expr<RealType, DerivativeOrder, ARG> acosh(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
atanh_expr<RealType, DerivativeOrder, ARG> atanh(const expression<RealType,DerivativeOrder, ARG> &arg)
{
return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
} // namespace reverse_mode
} // namespace differentiation
} // namespace math

266
include/boost/math/differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp Normal file
View File

@@ -0,0 +1,266 @@
// Copyright Maksym Zhelyenzyakov 2025-2026.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
#ifndef REVERSE_MODE_AUTODIFF_STL_NO_ET_HPP
#define REVERSE_MODE_AUTODIFF_STL_NO_ET_HPP
#include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp>
namespace boost {
namespace math {
namespace differentiation {
namespace reverse_mode {
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> fabs(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> abs(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return fabs(arg);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> ceil(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> floor(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> exp(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
rvar<RealType, DerivativeOrder> pow(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType2,
typename RealType1,
size_t DerivativeOrder,
typename ARG,
typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
rvar<RealType1, DerivativeOrder> pow(const expression<RealType1, DerivativeOrder, ARG> &arg,
const RealType2 &v)
{
return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> pow(const RealType &v,
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> log(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> sqrt(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
{
BOOST_MATH_STD_USING
frexp(arg.evaluate(), i);
return arg / pow(static_cast<RealType>(2.0), *i);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
{
BOOST_MATH_STD_USING
return arg * pow(static_cast<RealType>(2.0), i);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> cos(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> sin(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> tan(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> acos(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> asin(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> atan(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
};
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
rvar<RealType, DerivativeOrder> atan2(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> atan2(const expression<RealType, DerivativeOrder, ARG> &arg,
const RealType &v)
{
return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> atan2(const RealType &v,
const expression<RealType, DerivativeOrder, ARG> &arg)
{
return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
};
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> trunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs,
const expression<RealType, DerivativeOrder, RHS> &rhs)
{
return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
{
return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
{
return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> round(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return iround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
BOOST_MATH_STD_USING
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return lround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return llround(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return itrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return ltrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
{
rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
return lltrunc(tmp.item());
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> sinh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> cosh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> tanh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> log10(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> asinh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> acosh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
template<typename RealType, size_t DerivativeOrder, typename ARG>
rvar<RealType, DerivativeOrder> atanh(const expression<RealType, DerivativeOrder, ARG> &arg)
{
return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
}
} // namespace reverse_mode
} // namespace differentiation
} // namespace math
} // namespace boost
#endif