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