ExprContainer with value semantics

CMakeLists.txt

@@ -306,16 +306,30 @@ set(SeQuant_symb_src
         SeQuant/core/context.hpp
         SeQuant/core/expressions/abstract_tensor.cpp
         SeQuant/core/expressions/abstract_tensor.hpp
+        SeQuant/core/expressions/constant.cpp
+        SeQuant/core/expressions/constant.hpp
         SeQuant/core/expressions/expr.cpp
         SeQuant/core/expressions/expr.hpp
         SeQuant/core/expressions/expr_algorithms.cpp
         SeQuant/core/expressions/expr_algorithms.hpp
+        SeQuant/core/expressions/expr_container.cpp
+        SeQuant/core/expressions/expr_container.hpp
         SeQuant/core/expressions/expr_operators.hpp
+        SeQuant/core/expressions/expr_ptr.cpp
+        SeQuant/core/expressions/expr_ptr.hpp
         SeQuant/core/expressions/expr_range.hpp
+        SeQuant/core/expressions/power.cpp
+        SeQuant/core/expressions/power.hpp
+        SeQuant/core/expressions/product.cpp
+        SeQuant/core/expressions/product.hpp
         SeQuant/core/expressions/result_expr.cpp
         SeQuant/core/expressions/result_expr.hpp
+        SeQuant/core/expressions/sum.cpp
+        SeQuant/core/expressions/sum.hpp
         SeQuant/core/expressions/tensor.cpp
         SeQuant/core/expressions/tensor.hpp
+        SeQuant/core/expressions/variable.cpp
+        SeQuant/core/expressions/variable.hpp
         SeQuant/core/hash.cpp
         SeQuant/core/hash.hpp
         SeQuant/core/hugenholtz.hpp

SeQuant/core/export/export.hpp

@@ -539,10 +539,10 @@ void track_usage(const EvalNode<T> &node, PreprocessResult &result) {
     handle_variable(expr.as<Variable>());
   } else if (expr.is<Power>()) {
     const Power &power = expr.as<Power>();
-    if (power.base().is<Tensor>()) {
-      handle_tensor(power.base().as<Tensor>());
-    } else if (power.base().is<Variable>()) {
-      handle_variable(power.base().as<Variable>());
+    if (power.base()->is<Tensor>()) {
+      handle_tensor(power.base()->as<Tensor>());
+    } else if (power.base()->is<Variable>()) {
+      handle_variable(power.base()->as<Variable>());
     }
   }
 }
@@ -762,10 +762,10 @@ class PreprocessVisitor {
       handle_variable(node.left()->as_variable());
     } else if (node.left()->is_power()) {
       const Power &power = node.left()->as_power();
-      if (power.base().is<Tensor>()) {
-        handle_tensor(power.base().as<Tensor>());
-      } else if (power.base().is<Variable>()) {
-        handle_variable(power.base().as<Variable>());
+      if (power.base()->is<Tensor>()) {
+        handle_tensor(power.base()->as<Tensor>());
+      } else if (power.base()->is<Variable>()) {
+        handle_variable(power.base()->as<Variable>());
       }
     }
 
@@ -775,10 +775,10 @@ class PreprocessVisitor {
       handle_variable(node.right()->as_variable());
     } else if (node.right()->is_power()) {
       const Power &power = node.right()->as_power();
-      if (power.base().is<Tensor>()) {
-        handle_tensor(power.base().as<Tensor>());
-      } else if (power.base().is<Variable>()) {
-        handle_variable(power.base().as<Variable>());
+      if (power.base()->is<Tensor>()) {
+        handle_tensor(power.base()->as<Tensor>());
+      } else if (power.base()->is<Variable>()) {
+        handle_variable(power.base()->as<Variable>());
       }
     }
   }

SeQuant/core/export/itf.hpp

@@ -215,7 +215,7 @@ class ItfGenerator : public Generator<Context> {
   }
 
   std::string represent(const Power &power, const Context &ctx) const override {
-    const ExprPtr &base = power.base();
+    const ExprContainer &base = power.base();
     // ITF can only express powers of Constants
     if (!base->is<Constant>()) {
       throw Exception(

SeQuant/core/export/julia_tensor_operations.hpp

@@ -130,7 +130,7 @@ class JuliaTensorOperationsGenerator : public Generator<Context> {
   }
 
   std::string represent(const Power &power, const Context &ctx) const override {
-    const ExprPtr &base = power.base();
+    const ExprContainer &base = power.base();
     std::string base_str = to_julia_expr(*base, ctx);
     if (base->is<Variable>() && base->as<Variable>().conjugated()) {
       base_str = wrap_conj(std::move(base_str));

SeQuant/core/export/python_einsum.hpp

@@ -198,7 +198,7 @@ class PythonEinsumGeneratorBase : public Generator<Context> {
   }
 
   std::string represent(const Power &power, const Context &ctx) const override {
-    const ExprPtr &base = power.base();
+    const ExprContainer &base = power.base();
     std::string base_str = stringify_scalar(*base, ctx);
     if (base->is<Variable>() && base->as<Variable>().conjugated()) {
       base_str = wrap_conj(std::move(base_str));

SeQuant/core/export/text_generator.hpp

@@ -121,7 +121,7 @@ class TextGenerator : public Generator<Context> {
   }
 
   std::string represent(const Power &power, const Context &ctx) const override {
-    const ExprPtr &base = power.base();
+    const ExprContainer &base = power.base();
     std::string base_str = stringify(*base, ctx);
     if (base->is<Variable>() && base->as<Variable>().conjugated()) {
       base_str = wrap_conj(std::move(base_str));

SeQuant/core/export/utils.cpp

@@ -4,8 +4,7 @@
 
 #include <SeQuant/core/export/utils.hpp>
 
-#include <SeQuant/core/expressions/constant.hpp>
-#include <SeQuant/core/expressions/expr.hpp>
+#include <SeQuant/core/expr.hpp>
 #include <SeQuant/core/rational.hpp>
 
 #include <sstream>
@@ -30,7 +29,7 @@ std::string format_power_exponent(const Power::exponent_type &exponent,
   return ss.str();
 }
 
-std::string format_power_base(const ExprPtr &base, std::string base_str) {
+std::string format_power_base(const ExprContainer &base, std::string base_str) {
   if (base->is<Constant>()) {
     const auto &v = base->as<Constant>().value();
     if (v.imag() == 0 &&

SeQuant/core/export/utils.hpp

@@ -5,9 +5,7 @@
 #ifndef SEQUANT_CORE_EXPORT_UTILS_HPP
 #define SEQUANT_CORE_EXPORT_UTILS_HPP
 
-#include <SeQuant/core/expr_fwd.hpp>
-#include <SeQuant/core/expressions/expr_ptr.hpp>
-#include <SeQuant/core/expressions/power.hpp>
+#include <SeQuant/core/expr.hpp>
 
 #include <string>
 
@@ -27,7 +25,7 @@ std::string format_power_exponent(const Power::exponent_type &exponent,
 /// @param base_str @p base already rendered to a string by the caller
 /// @return @p base_str, wrapped in parens iff @p base is a Constant whose
 ///         value is a non-integer or negative real
-std::string format_power_base(const ExprPtr &base, std::string base_str);
+std::string format_power_base(const ExprContainer &base, std::string base_str);
 
 }  // namespace sequant::detail
 

SeQuant/core/expr.hpp

@@ -9,6 +9,7 @@
 #include <SeQuant/core/expressions/constant.hpp>
 #include <SeQuant/core/expressions/expr.hpp>
 #include <SeQuant/core/expressions/expr_algorithms.hpp>
+#include <SeQuant/core/expressions/expr_container.hpp>
 #include <SeQuant/core/expressions/expr_iterator.hpp>
 #include <SeQuant/core/expressions/expr_operators.hpp>
 #include <SeQuant/core/expressions/expr_ptr.hpp>

SeQuant/core/expr_fwd.hpp

@@ -12,6 +12,7 @@ namespace sequant {
 class Expr;
 class ResultExpr;
 class ExprPtr;
+class ExprContainer;
 
 class Labeled;
 class Constant;

SeQuant/core/expressions/constant.cpp

@@ -0,0 +1,117 @@
+#include <SeQuant/core/expressions/constant.hpp>
+#include <SeQuant/core/expressions/expr_ptr.hpp>
+#include <SeQuant/core/io/latex/latex.hpp>
+#include <SeQuant/core/utility/exception.hpp>
+#include <SeQuant/core/utility/macros.hpp>
+
+#include <memory>
+
+namespace sequant {
+
+std::wstring Constant::to_latex() const {
+  return L"{" + io::latex::to_string(value()) + L"}";
+}
+
+Expr::type_id_type Constant::type_id() const { return get_type_id<Constant>(); }
+
+bool Constant::is_scalar() const { return true; }
+
+void Constant::adjoint() {
+  value_ = conj(value_);
+  reset_hash_value();
+}
+
+Constant &Constant::operator*=(const Constant &that) {
+  value_ *= that.value();
+
+  reset_hash_value();
+
+  return *this;
+}
+
+Constant &Constant::operator*=(const Expr &that) {
+  if (!that.is<Constant>()) {
+    throw Exception("Constant::operator*=(that): not valid for that");
+  }
+
+  return *this *= that.as<Constant>();
+}
+
+Constant &Constant::operator+=(const Constant &that) {
+  value_ += that.value();
+
+  reset_hash_value();
+
+  return *this;
+}
+
+Constant &Constant::operator+=(const Expr &that) {
+  if (!that.is<Constant>()) {
+    throw Exception("Constant::operator+=(that): not valid for that");
+  }
+
+  return *this += that.as<Constant>();
+}
+
+Constant &Constant::operator-=(const Constant &that) {
+  value_ -= that.value();
+
+  reset_hash_value();
+
+  return *this;
+}
+
+Constant &Constant::operator-=(const Expr &that) {
+  if (!that.is<Constant>()) {
+    throw Exception("Constant::operator-=(that): not valid for that");
+  }
+
+  return *this -= that.as<Constant>();
+}
+
+bool Constant::is_zero(scalar_type v) { return v.is_zero(); }
+
+bool Constant::is_zero() const { return is_zero(this->value()); }
+
+std::unique_ptr<Expr> Constant::unique_copy() const {
+  return std::make_unique<Constant>(this->value());
+}
+
+Expr::hash_type Constant::memoizing_hash() const {
+  if (!hash_value_) {
+    hash_value_ = hash::value(value_);
+  } else {
+    SEQUANT_ASSERT(*hash_value_ == hash::value(value_));
+  }
+  return *hash_value_;
+}
+
+bool Constant::static_equal(const Expr &that) const {
+  return value() == static_cast<const Constant &>(that).value();
+}
+
+Constant operator*(const Constant &lhs, const Constant &rhs) {
+  Constant result(lhs);
+
+  result *= rhs;
+
+  return result;
+}
+
+Constant operator+(const Constant &lhs, const Constant &rhs) {
+  Constant result(lhs);
+
+  result += rhs;
+
+  return result;
+}
+
+Constant operator-(const Constant &lhs, const Constant &rhs) {
+  Constant result(lhs);
+
+  result -= rhs;
+
+  return result;
+}
+
+}  // namespace sequant

SeQuant/core/expressions/constant.hpp

@@ -3,17 +3,18 @@
 
 #include <SeQuant/core/complex.hpp>
 #include <SeQuant/core/expressions/expr.hpp>
-#include <SeQuant/core/expressions/expr_ptr.hpp>
-#include <SeQuant/core/io/latex/latex.hpp>
 #include <SeQuant/core/rational.hpp>
 #include <SeQuant/core/utility/macros.hpp>
 
 #include <boost/numeric/conversion/cast.hpp>
 
+#include <memory>
 #include <string>
 
 namespace sequant {
 
+class ExprPtr;
+
 // implementation details of Constant; prefer sequant::detail over an unnamed
 // namespace in a header (see CppCoreGuidelines SF.21)
 namespace detail {
@@ -67,70 +68,47 @@ class Constant : public Expr {
       throw Exception("Constant::value<T>: cannot convert value to type T");
   }
 
-  std::wstring to_latex() const override {
-    return L"{" + io::latex::to_string(value()) + L"}";
-  }
-
-  type_id_type type_id() const override { return get_type_id<Constant>(); }
+  std::wstring to_latex() const override;
 
-  bool is_scalar() const override { return true; }
+  type_id_type type_id() const override;
 
-  ExprPtr clone() const override { return ex<Constant>(this->value()); }
+  bool is_scalar() const override;
 
   /// @brief adjoint of a Constant is its complex conjugate
   virtual void adjoint() override;
 
-  virtual Expr &operator*=(const Expr &that) override {
-    if (that.is<Constant>()) {
-      value_ *= that.as<Constant>().value();
-    } else {
-      throw Exception("Constant::operator*=(that): not valid for that");
-    }
-    return *this;
-  }
+  Constant &operator*=(const Constant &that);
+  Constant &operator*=(const Expr &that);
 
-  virtual Expr &operator+=(const Expr &that) override {
-    if (that.is<Constant>()) {
-      value_ += that.as<Constant>().value();
-    } else {
-      throw Exception("Constant::operator+=(that): not valid for that");
-    }
-    return *this;
-  }
+  Constant &operator+=(const Constant &that);
+  Constant &operator+=(const Expr &that);
 
-  virtual Expr &operator-=(const Expr &that) override {
-    if (that.is<Constant>()) {
-      value_ -= that.as<Constant>().value();
-    } else {
-      throw Exception("Constant::operator-=(that): not valid for that");
-    }
-    return *this;
-  }
+  Constant &operator-=(const Constant &that);
+  Constant &operator-=(const Expr &that);
 
   /// @param[in] v a scalar
   /// @return true if this is zero
-  static bool is_zero(scalar_type v) { return v.is_zero(); }
+  static bool is_zero(scalar_type v);
 
   /// @return `Constant::is_zero(this->value())`
-  bool is_zero() const final { return is_zero(this->value()); }
+  bool is_zero() const final;
+
+ protected:
+  std::unique_ptr<Expr> unique_copy() const override;
 
  private:
   scalar_type value_;
 
-  hash_type memoizing_hash() const override {
-    if (!hash_value_) {
-      hash_value_ = hash::value(value_);
-    } else {
-      SEQUANT_ASSERT(*hash_value_ == hash::value(value_));
-    }
-    return *hash_value_;
-  }
+  hash_type memoizing_hash() const override;
+
+  bool static_equal(const Expr &that) const override;
 
-  bool static_equal(const Expr &that) const override {
-    return value() == static_cast<const Constant &>(that).value();
-  }
 };  // class Constant
 
+Constant operator*(const Constant &lhs, const Constant &rhs);
+Constant operator+(const Constant &lhs, const Constant &rhs);
+Constant operator-(const Constant &lhs, const Constant &rhs);
+
 }  // namespace sequant
 
 #endif  // SEQUANT_EXPRESSIONS_CONSTANT_HPP