Extend overloads for arithmetic operators of ExprPtr

SeQuant/core/expressions/expr_operators.hpp

@@ -12,6 +12,7 @@
 #include <SeQuant/core/expressions/sum.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 
+#include <concepts>
 #include <memory>
 
 namespace sequant {
@@ -65,18 +66,6 @@ inline ExprPtr operator^(const ExprPtr &left, const ExprPtr &right) {
   SEQUANT_UNREACHABLE;
 }
 
-template <typename T>
-  requires(std::constructible_from<Constant, T>)
-inline ExprPtr operator*(T left, const ExprPtr &right) {
-  return ex<Constant>(std::move(left)) * right;
-}
-
-template <typename T>
-  requires(std::constructible_from<Constant, T>)
-inline ExprPtr operator*(const ExprPtr &left, T right) {
-  return left * ex<Constant>(std::move(right));
-}
-
 inline ExprPtr operator+(const ExprPtr &left, const ExprPtr &right) {
   auto left_is_sum = left->is<Sum>();
   auto right_is_sum = right->is<Sum>();
@@ -114,6 +103,52 @@ inline ExprPtr operator-(const ExprPtr &left, const ExprPtr &right) {
   SEQUANT_UNREACHABLE;
 }
 
+template <typename T>
+  requires(std::constructible_from<Constant, T>)
+ExprPtr operator+(const ExprPtr &lhs, T &&rhs) {
+  return lhs + ex<Constant>(std::forward<T>(rhs));
+}
+
+template <typename T>
+  requires(std::constructible_from<Constant, T>)
+ExprPtr operator+(T &&lhs, const ExprPtr &rhs) {
+  return ex<Constant>(std::forward<T>(lhs)) + rhs;
+}
+
+template <typename T>
+  requires(std::constructible_from<Constant, T>)
+ExprPtr operator-(const ExprPtr &lhs, T &&rhs) {
+  return lhs - ex<Constant>(std::forward<T>(rhs));
+}
+
+template <typename T>
+  requires(std::constructible_from<Constant, T>)
+ExprPtr operator-(T &&lhs, const ExprPtr &rhs) {
+  return ex<Constant>(std::forward<T>(lhs)) - rhs;
+}
+
+template <typename T>
+  requires(std::constructible_from<Constant, T>)
+ExprPtr operator*(const ExprPtr &lhs, T &&rhs) {
+  return lhs * ex<Constant>(std::forward<T>(rhs));
+}
+
+template <typename T>
+  requires(std::constructible_from<Constant, T>)
+ExprPtr operator*(T &&lhs, const ExprPtr &rhs) {
+  return ex<Constant>(std::forward<T>(lhs)) * rhs;
+}
+
+template <typename T>
+  requires(std::is_arithmetic_v<T>)
+ExprPtr operator/(const ExprPtr &lhs, T &&rhs) {
+  return lhs * ex<Constant>(rational(1, std::forward<T>(rhs)));
+}
+
+inline ExprPtr operator/(const ExprPtr &lhs, const Constant &rhs) {
+  return lhs * ex<Constant>(1.0 / rhs.value());
+}
+
 }  // namespace sequant
 
 #endif  // SEQUANT_EXPRESSIONS_OPERATORS_HPP

tests/unit/test_expr.cpp

@@ -817,6 +817,48 @@ TEST_CASE("expr", "[elements]") {
       ex3.reset();
       REQUIRE_NOTHROW(ex3 *= ex2);
       CHECK(ex3 == ex2);
+
+      SECTION("Overloads with basic numeric types") {
+        ex1 = ex<Constant>(1);
+
+        ExprPtr res = ex1 + 1;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(2));
+
+        res = 1 + ex1;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(2));
+
+        res = ex1 - 1;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(0));
+
+        res = 1 - ex1;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(0));
+
+        res = ex1 * 5.0;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(5));
+
+        res = 5.0 * ex1;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(5));
+
+        // This will be rewritten as (1/5.0) * ex1
+        res = ex1 / 5.0;
+        simplify(res);
+        REQUIRE(res == ex<Constant>(rational(1, 5)));
+      }
+
+      SECTION("Divide by Constant") {
+        ex1 = ex<Constant>(5);
+
+        ExprPtr res = ex1 / Constant(3);
+        simplify(res);
+
+        REQUIRE(res == ex<Constant>(rational(5, 3)));
+      }
     }
   }