differentiation/detail/reverse_mode_autodiff_stl_no_et.hpp

0001 //           Copyright Maksym Zhelyenzyakov 2025-2026.
0002 // Distributed under the Boost Software License, Version 1.0.
0003 //      (See accompanying file LICENSE_1_0.txt or copy at
0004 //           https://www.boost.org/LICENSE_1_0.txt)
0005 #ifndef REVERSE_MODE_AUTODIFF_STL_NO_ET_HPP
0006 #define REVERSE_MODE_AUTODIFF_STL_NO_ET_HPP
0007
0008 #include <boost/math/differentiation/detail/reverse_mode_autodiff_stl_expressions.hpp>
0009 namespace boost {
0010 namespace math {
0011 namespace differentiation {
0012 namespace reverse_mode {
0013
0014 template<typename RealType, size_t DerivativeOrder, typename ARG>
0015 rvar<RealType, DerivativeOrder> fabs(const expression<RealType, DerivativeOrder, ARG> &arg)
0016 {
0017     return fabs_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0018 }
0019 template<typename RealType, size_t DerivativeOrder, typename ARG>
0020 rvar<RealType, DerivativeOrder> abs(const expression<RealType, DerivativeOrder, ARG> &arg)
0021 {
0022     return fabs(arg);
0023 }
0024 template<typename RealType, size_t DerivativeOrder, typename ARG>
0025 rvar<RealType, DerivativeOrder> ceil(const expression<RealType, DerivativeOrder, ARG> &arg)
0026 {
0027     return ceil_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0028 }
0029 template<typename RealType, size_t DerivativeOrder, typename ARG>
0030 rvar<RealType, DerivativeOrder> floor(const expression<RealType, DerivativeOrder, ARG> &arg)
0031 {
0032     return floor_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0033 }
0034
0035 template<typename RealType, size_t DerivativeOrder, typename ARG>
0036 rvar<RealType, DerivativeOrder> exp(const expression<RealType, DerivativeOrder, ARG> &arg)
0037 {
0038     return exp_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0039 }
0040
0041 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0042 rvar<RealType, DerivativeOrder> pow(const expression<RealType, DerivativeOrder, LHS> &lhs,
0043                                     const expression<RealType, DerivativeOrder, RHS> &rhs)
0044 {
0045     return pow_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0046 }
0047
0048 template<typename RealType2,
0049          typename RealType1,
0050          size_t DerivativeOrder,
0051          typename ARG,
0052          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0053 rvar<RealType1, DerivativeOrder> pow(const expression<RealType1, DerivativeOrder, ARG> &arg,
0054                                      const RealType2                                   &v)
0055 {
0056     return expr_pow_float_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0057 };
0058
0059 template<typename RealType, size_t DerivativeOrder, typename ARG>
0060 rvar<RealType, DerivativeOrder> pow(const RealType                                   &v,
0061                                     const expression<RealType, DerivativeOrder, ARG> &arg)
0062 {
0063     return float_pow_expr_expr<RealType, DerivativeOrder, ARG>(arg, v);
0064 };
0065
0066 template<typename RealType, size_t DerivativeOrder, typename ARG>
0067 rvar<RealType, DerivativeOrder> log(const expression<RealType, DerivativeOrder, ARG> &arg)
0068 {
0069     return log_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0070 };
0071
0072 template<typename RealType, size_t DerivativeOrder, typename ARG>
0073 rvar<RealType, DerivativeOrder> sqrt(const expression<RealType, DerivativeOrder, ARG> &arg)
0074 {
0075     return sqrt_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0076 };
0077
0078 template<typename RealType, size_t DerivativeOrder, typename ARG>
0079 rvar<RealType, DerivativeOrder> frexp(const expression<RealType, DerivativeOrder, ARG> &arg, int *i)
0080 {
0081     BOOST_MATH_STD_USING
0082     frexp(arg.evaluate(), i);
0083     return arg / pow(static_cast<RealType>(2.0), *i);
0084 }
0085
0086 template<typename RealType, size_t DerivativeOrder, typename ARG>
0087 auto ldexp(const expression<RealType, DerivativeOrder, ARG> &arg, const int &i)
0088 {
0089     BOOST_MATH_STD_USING
0090     return arg * pow(static_cast<RealType>(2.0), i);
0091 }
0092
0093 template<typename RealType, size_t DerivativeOrder, typename ARG>
0094 rvar<RealType, DerivativeOrder> cos(const expression<RealType, DerivativeOrder, ARG> &arg)
0095 {
0096     return cos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0097 };
0098
0099 template<typename RealType, size_t DerivativeOrder, typename ARG>
0100 rvar<RealType, DerivativeOrder> sin(const expression<RealType, DerivativeOrder, ARG> &arg)
0101 {
0102     return sin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0103 };
0104
0105 template<typename RealType, size_t DerivativeOrder, typename ARG>
0106 rvar<RealType, DerivativeOrder> tan(const expression<RealType, DerivativeOrder, ARG> &arg)
0107 {
0108     return tan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0109 };
0110
0111 template<typename RealType, size_t DerivativeOrder, typename ARG>
0112 rvar<RealType, DerivativeOrder> acos(const expression<RealType, DerivativeOrder, ARG> &arg)
0113 {
0114     return acos_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0115 };
0116
0117 template<typename RealType, size_t DerivativeOrder, typename ARG>
0118 rvar<RealType, DerivativeOrder> asin(const expression<RealType, DerivativeOrder, ARG> &arg)
0119 {
0120     return asin_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0121 };
0122
0123 template<typename RealType, size_t DerivativeOrder, typename ARG>
0124 rvar<RealType, DerivativeOrder> atan(const expression<RealType, DerivativeOrder, ARG> &arg)
0125 {
0126     return atan_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0127 };
0128
0129 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0130 rvar<RealType, DerivativeOrder> atan2(const expression<RealType, DerivativeOrder, LHS> &lhs,
0131                                       const expression<RealType, DerivativeOrder, RHS> &rhs)
0132 {
0133     return atan2_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0134 }
0135
0136 template<typename RealType, size_t DerivativeOrder, typename ARG>
0137 rvar<RealType, DerivativeOrder> atan2(const expression<RealType, DerivativeOrder, ARG> &arg,
0138                                       const RealType                                   &v)
0139 {
0140     return atan2_right_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
0141 };
0142
0143 template<typename RealType, size_t DerivativeOrder, typename ARG>
0144 rvar<RealType, DerivativeOrder> atan2(const RealType                                   &v,
0145                                       const expression<RealType, DerivativeOrder, ARG> &arg)
0146 {
0147     return atan2_left_float_expr<RealType, DerivativeOrder, ARG>(arg, v);
0148 };
0149
0150 template<typename RealType, size_t DerivativeOrder, typename ARG>
0151 rvar<RealType, DerivativeOrder> trunc(const expression<RealType, DerivativeOrder, ARG> &arg)
0152 {
0153     return trunc_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0154 }
0155
0156 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0157 auto fmod(const expression<RealType, DerivativeOrder, LHS> &lhs,
0158           const expression<RealType, DerivativeOrder, RHS> &rhs)
0159 {
0160     return fmod_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0161 }
0162
0163 template<typename RealType, size_t DerivativeOrder, typename ARG>
0164 auto fmod(const expression<RealType, DerivativeOrder, ARG> &lhs, const RealType rhs)
0165 {
0166     return fmod_right_float_expr<RealType, DerivativeOrder, ARG>(lhs, rhs);
0167 }
0168
0169 template<typename RealType, size_t DerivativeOrder, typename ARG>
0170 auto fmod(const RealType lhs, const expression<RealType, DerivativeOrder, ARG> &rhs)
0171 {
0172     return fmod_left_float_expr<RealType, DerivativeOrder, ARG>(rhs, lhs);
0173 }
0174
0175 template<typename RealType, size_t DerivativeOrder, typename ARG>
0176 rvar<RealType, DerivativeOrder> round(const expression<RealType, DerivativeOrder, ARG> &arg)
0177 {
0178     return round_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0179 }
0180
0181 template<typename RealType, size_t DerivativeOrder, typename ARG>
0182 int iround(const expression<RealType, DerivativeOrder, ARG> &arg)
0183 {
0184     rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
0185     return iround(tmp.item());
0186 }
0187 template<typename RealType, size_t DerivativeOrder, typename ARG>
0188 long lround(const expression<RealType, DerivativeOrder, ARG> &arg)
0189 {
0190     BOOST_MATH_STD_USING
0191     rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
0192     return lround(tmp.item());
0193 }
0194
0195 template<typename RealType, size_t DerivativeOrder, typename ARG>
0196 long long llround(const expression<RealType, DerivativeOrder, ARG> &arg)
0197 {
0198     rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
0199     return llround(tmp.item());
0200 }
0201
0202 template<typename RealType, size_t DerivativeOrder, typename ARG>
0203 int itrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
0204 {
0205     rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
0206     return itrunc(tmp.item());
0207 }
0208
0209 template<typename RealType, size_t DerivativeOrder, typename ARG>
0210 long ltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
0211 {
0212     rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
0213     return ltrunc(tmp.item());
0214 }
0215
0216 template<typename RealType, size_t DerivativeOrder, typename ARG>
0217 long long lltrunc(const expression<RealType, DerivativeOrder, ARG> &arg)
0218 {
0219     rvar<RealType, DerivativeOrder> tmp = arg.evaluate();
0220     return lltrunc(tmp.item());
0221 }
0222
0223 template<typename RealType, size_t DerivativeOrder, typename ARG>
0224 rvar<RealType, DerivativeOrder> sinh(const expression<RealType, DerivativeOrder, ARG> &arg)
0225 {
0226     return sinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0227 }
0228
0229 template<typename RealType, size_t DerivativeOrder, typename ARG>
0230 rvar<RealType, DerivativeOrder> cosh(const expression<RealType, DerivativeOrder, ARG> &arg)
0231 {
0232     return cosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0233 }
0234
0235 template<typename RealType, size_t DerivativeOrder, typename ARG>
0236 rvar<RealType, DerivativeOrder> tanh(const expression<RealType, DerivativeOrder, ARG> &arg)
0237 {
0238     return tanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0239 }
0240
0241 template<typename RealType, size_t DerivativeOrder, typename ARG>
0242 rvar<RealType, DerivativeOrder> log10(const expression<RealType, DerivativeOrder, ARG> &arg)
0243 {
0244     return log10_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0245 }
0246 template<typename RealType, size_t DerivativeOrder, typename ARG>
0247 rvar<RealType, DerivativeOrder> asinh(const expression<RealType, DerivativeOrder, ARG> &arg)
0248 {
0249     return asinh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0250 }
0251 template<typename RealType, size_t DerivativeOrder, typename ARG>
0252 rvar<RealType, DerivativeOrder> acosh(const expression<RealType, DerivativeOrder, ARG> &arg)
0253 {
0254     return acosh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0255 }
0256 template<typename RealType, size_t DerivativeOrder, typename ARG>
0257 rvar<RealType, DerivativeOrder> atanh(const expression<RealType, DerivativeOrder, ARG> &arg)
0258 {
0259     return atanh_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(0.0));
0260 }
0261 } // namespace reverse_mode
0262 } // namespace differentiation
0263 } // namespace math
0264 } // namespace boost
0265
0266 #endif