differentiation/detail/reverse_mode_autodiff_basic_ops_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
0006 #ifndef REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
0007 #define REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP
0008
0009 #include <boost/math/differentiation/detail/reverse_mode_autodiff_basic_operator_expressions.hpp>
0010 namespace boost {
0011 namespace math {
0012 namespace differentiation {
0013 namespace reverse_mode {
0014 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0015 mult_expr<RealType, DerivativeOrder, LHS, RHS> operator*(
0016     const expression<RealType, DerivativeOrder, LHS> &lhs,
0017     const expression<RealType, DerivativeOrder, RHS> &rhs)
0018 {
0019     return mult_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0020 }
0021
0022 /** @brief type promotion is handled by casting the numeric type to
0023  *  the type inside expression. This is to avoid converting the
0024  *  entire tape in case you have something like double * rvar<float>
0025  *  */
0026 template<typename RealType2,
0027          typename RealType1,
0028          size_t DerivativeOrder,
0029          typename ARG,
0030          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0031 mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
0032     const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
0033 {
0034     return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0035 }
0036 template<typename RealType2,
0037          typename RealType1,
0038          size_t DerivativeOrder,
0039          typename ARG,
0040          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0041 mult_const_expr<RealType1, DerivativeOrder, ARG> operator*(
0042     const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
0043 {
0044     return mult_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0045 }
0046 /****************************************************************************************************************/
0047 /* + */
0048 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0049 add_expr<RealType, DerivativeOrder, LHS, RHS> operator+(
0050     const expression<RealType, DerivativeOrder, LHS> &lhs,
0051     const expression<RealType, DerivativeOrder, RHS> &rhs)
0052 {
0053     return add_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0054 }
0055 template<typename RealType2,
0056          typename RealType1,
0057          size_t DerivativeOrder,
0058          typename ARG,
0059          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0060 add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
0061     const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
0062 {
0063     return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0064 }
0065 template<typename RealType2,
0066          typename RealType1,
0067          size_t DerivativeOrder,
0068          typename ARG,
0069          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0070 add_const_expr<RealType1, DerivativeOrder, ARG> operator+(
0071     const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
0072 {
0073     return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0074 }
0075 /****************************************************************************************************************/
0076 /* - overload */
0077 /** @brief
0078  *  negation (-1.0*rvar) */
0079 template<typename RealType, size_t DerivativeOrder, typename ARG>
0080 mult_const_expr<RealType, DerivativeOrder, ARG> operator-(
0081     const expression<RealType, DerivativeOrder, ARG> &arg)
0082 {
0083     return mult_const_expr<RealType, DerivativeOrder, ARG>(arg, static_cast<RealType>(-1.0));
0084 }
0085
0086 /** @brief
0087  *  subtraction rvar-rvar */
0088 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0089 sub_expr<RealType, DerivativeOrder, LHS, RHS> operator-(
0090     const expression<RealType, DerivativeOrder, LHS> &lhs,
0091     const expression<RealType, DerivativeOrder, RHS> &rhs)
0092 {
0093     return sub_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0094 }
0095
0096 /** @brief
0097  *  subtraction float - rvar */
0098 template<typename RealType2,
0099          typename RealType1,
0100          size_t DerivativeOrder,
0101          typename ARG,
0102          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0103 add_const_expr<RealType1, DerivativeOrder, ARG> operator-(
0104     const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
0105 {
0106     /* rvar - float = rvar + (-float) */
0107     return add_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(-v));
0108 }
0109
0110 /** @brief
0111  *   subtraction float - rvar
0112  *  @return add_expr<neg_expr<ARG>>
0113  */
0114 template<typename RealType2,
0115          typename RealType1,
0116          size_t DerivativeOrder,
0117          typename ARG,
0118          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0119 auto operator-(const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
0120 {
0121     auto neg = -arg;
0122     return neg + static_cast<RealType1>(v);
0123 }
0124 /****************************************************************************************************************/
0125 /* / */
0126 template<typename RealType, size_t DerivativeOrder, typename LHS, typename RHS>
0127 div_expr<RealType, DerivativeOrder, LHS, RHS> operator/(
0128     const expression<RealType, DerivativeOrder, LHS> &lhs,
0129     const expression<RealType, DerivativeOrder, RHS> &rhs)
0130 {
0131     return div_expr<RealType, DerivativeOrder, LHS, RHS>(lhs, rhs);
0132 }
0133
0134 template<typename RealType2,
0135          typename RealType1,
0136          size_t DerivativeOrder,
0137          typename ARG,
0138          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0139 const_div_by_expr<RealType1, DerivativeOrder, ARG> operator/(
0140     const RealType2 &v, const expression<RealType1, DerivativeOrder, ARG> &arg)
0141 {
0142     return const_div_by_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0143 }
0144
0145 template<typename RealType2,
0146          typename RealType1,
0147          size_t DerivativeOrder,
0148          typename ARG,
0149          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0150 div_by_const_expr<RealType1, DerivativeOrder, ARG> operator/(
0151     const expression<RealType1, DerivativeOrder, ARG> &arg, const RealType2 &v)
0152 {
0153     return div_by_const_expr<RealType1, DerivativeOrder, ARG>(arg, static_cast<RealType1>(v));
0154 }
0155 } // namespace reverse_mode
0156 } // namespace differentiation
0157 } // namespace math
0158 } // namespace boost
0159
0160 #endif // REVERSE_MODE_AUTODIFF_BASIC_OPS_ET_HPP