differentiation/detail/reverse_mode_autodiff_comparison_operator_overloads.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_COMPARISON_OPERATOR_OVERLOADS_HPP
0007 #define REVERSE_MODE_AUTODIFF_COMPARISON_OPERATOR_OVERLOADS_HPP
0008 #include <boost/math/differentiation/detail/reverse_mode_autodiff_expression_template_base.hpp>
0009 namespace boost {
0010 namespace math {
0011 namespace differentiation {
0012 namespace reverse_mode {
0013 template<typename RealType, size_t DerivativeOrder1, size_t DerivativeOrder2, class LhsExpr, class RhsExpr>
0014 bool operator==(const expression<RealType, DerivativeOrder1, LhsExpr> &lhs,
0015                 const expression<RealType, DerivativeOrder2, RhsExpr> &rhs)
0016 {
0017     return lhs.evaluate() == rhs.evaluate();
0018 }
0019
0020 template<typename RealType2,
0021          typename RealType1,
0022          size_t DerivativeOrder,
0023          class ArgExpr,
0024          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0025 bool operator==(const expression<RealType1, DerivativeOrder, ArgExpr> &lhs, const RealType2 &rhs)
0026 {
0027     return lhs.evaluate() == static_cast<RealType1>(rhs);
0028 }
0029 template<typename RealType2,
0030          typename RealType1,
0031          size_t DerivativeOrder,
0032          class ArgExpr,
0033          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0034 bool operator==(const RealType2 &lhs, const expression<RealType1, DerivativeOrder, ArgExpr> &rhs)
0035 {
0036     return lhs == rhs.evaluate();
0037 }
0038
0039 template<typename RealType, size_t DerivativeOrder1, size_t DerivativeOrder2, class LhsExpr, class RhsExpr>
0040 bool operator!=(const expression<RealType, DerivativeOrder1, LhsExpr> &lhs,
0041                 const expression<RealType, DerivativeOrder2, RhsExpr> &rhs)
0042 {
0043     return lhs.evaluate() != rhs.evaluate();
0044 }
0045 template<typename RealType2,
0046          typename RealType1,
0047          size_t DerivativeOrder,
0048          class ArgExpr,
0049          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0050 bool operator!=(const expression<RealType1, DerivativeOrder, ArgExpr> &lhs, const RealType2 &rhs)
0051 {
0052     return lhs.evaluate() != rhs;
0053 }
0054 template<typename RealType2,
0055          typename RealType1,
0056          size_t DerivativeOrder,
0057          class ArgExpr,
0058          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0059 bool operator!=(const RealType2 &lhs, const expression<RealType1, DerivativeOrder, ArgExpr> &rhs)
0060 {
0061     return lhs != rhs.evaluate();
0062 }
0063
0064 template<typename RealType, size_t DerivativeOrder1, size_t DerivativeOrder2, class LhsExpr, class RhsExpr>
0065 bool operator<(const expression<RealType, DerivativeOrder1, LhsExpr> &lhs,
0066                const expression<RealType, DerivativeOrder2, RhsExpr> &rhs)
0067 {
0068     return lhs.evaluate() < rhs.evaluate();
0069 }
0070 template<typename RealType2,
0071          typename RealType1,
0072          size_t DerivativeOrder,
0073          class ArgExpr,
0074          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0075 bool operator<(const expression<RealType1, DerivativeOrder, ArgExpr> &lhs, const RealType2 &rhs)
0076 {
0077     return lhs.evaluate() < rhs;
0078 }
0079 template<typename RealType2,
0080          typename RealType1,
0081          size_t DerivativeOrder,
0082          class ArgExpr,
0083          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0084 bool operator<(const RealType2 &lhs, const expression<RealType1, DerivativeOrder, ArgExpr> &rhs)
0085 {
0086     return lhs < rhs.evaluate();
0087 }
0088
0089 template<typename RealType, size_t DerivativeOrder1, size_t DerivativeOrder2, class LhsExpr, class RhsExpr>
0090 bool operator>(const expression<RealType, DerivativeOrder1, LhsExpr> &lhs,
0091                const expression<RealType, DerivativeOrder2, RhsExpr> &rhs)
0092 {
0093     return lhs.evaluate() > rhs.evaluate();
0094 }
0095 template<typename RealType2,
0096          typename RealType1,
0097          size_t DerivativeOrder,
0098          class ArgExpr,
0099          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0100 bool operator>(const expression<RealType1, DerivativeOrder, ArgExpr> &lhs, const RealType2 &rhs)
0101 {
0102     return lhs.evaluate() > rhs;
0103 }
0104 template<typename RealType2,
0105          typename RealType1,
0106          size_t DerivativeOrder,
0107          class ArgExpr,
0108          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0109 bool operator>(const RealType2 &lhs, const expression<RealType1, DerivativeOrder, ArgExpr> &rhs)
0110 {
0111     return lhs > rhs.evaluate();
0112 }
0113
0114 template<typename RealType, size_t DerivativeOrder1, size_t DerivativeOrder2, class LhsExpr, class RhsExpr>
0115 bool operator<=(const expression<RealType, DerivativeOrder1, LhsExpr> &lhs,
0116                 const expression<RealType, DerivativeOrder2, RhsExpr> &rhs)
0117 {
0118     return lhs.evaluate() <= rhs.evaluate();
0119 }
0120 template<typename RealType2,
0121          typename RealType1,
0122          size_t DerivativeOrder,
0123          class ArgExpr,
0124          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0125 bool operator<=(const expression<RealType1, DerivativeOrder, ArgExpr> &lhs, const RealType2 &rhs)
0126 {
0127     return lhs.evaluate() <= rhs;
0128 }
0129 template<typename RealType2,
0130          typename RealType1,
0131          size_t DerivativeOrder,
0132          class ArgExpr,
0133          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0134 bool operator<=(const RealType2 &lhs, const expression<RealType1, DerivativeOrder, ArgExpr> &rhs)
0135 {
0136     return lhs <= rhs.evaluate();
0137 }
0138
0139 template<typename RealType, size_t DerivativeOrder1, size_t DerivativeOrder2, class LhsExpr, class RhsExpr>
0140 bool operator>=(const expression<RealType, DerivativeOrder1, LhsExpr> &lhs,
0141                 const expression<RealType, DerivativeOrder2, RhsExpr> &rhs)
0142 {
0143     return lhs.evaluate() >= rhs.evaluate();
0144 }
0145 template<typename RealType2,
0146          typename RealType1,
0147          size_t DerivativeOrder,
0148          class ArgExpr,
0149          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0150 bool operator>=(const expression<RealType1, DerivativeOrder, ArgExpr> &lhs, const RealType2 &rhs)
0151 {
0152     return lhs.evaluate() >= rhs;
0153 }
0154 template<typename RealType2,
0155          typename RealType1,
0156          size_t DerivativeOrder,
0157          class ArgExpr,
0158          typename = typename std::enable_if<!detail::is_expression<RealType2>::value>::type>
0159 bool operator>=(const RealType2 &lhs, const expression<RealType1, DerivativeOrder, ArgExpr> &rhs)
0160 {
0161     return lhs >= rhs.evaluate();
0162 }
0163 } // namespace reverse_mode
0164 } // namespace differentiation
0165 } // namespace math
0166 } // namespace boost
0167 #endif // REVERSE_MODE_AUTODIFF_COMPARISON_OPERATOR_OVERLOADS_HPP