ExpressionCell.h

#pragma once
 
#include <vector>
 
#include "delpi/symbolic/Expression.h"
#include "delpi/util/SelfReferenceCountingObject.hpp"
#include "delpi/util/intrusive_ptr.hpp"
 
namespace delpi {

class ExpressionCell : public SelfReferenceCountingObject {
 public:
  using Addend = Expression::Addend;
  using Addends = Expression::Addends;
  using SubstitutionMap = Expression::SubstitutionMap;

  [[nodiscard]] std::vector<Variable> variables() const;
  [[nodiscard]] const Addends& addends() const noexcept { return addends_; }

  [[nodiscard]] bool equal_to(const ExpressionCell& o) const noexcept;
  [[nodiscard]] bool less(const ExpressionCell& o) const noexcept;
  [[nodiscard]] std::size_t hash() const noexcept;

  ExpressionCell& Add(const Variable& var, const mpq_class& coeff);
  ExpressionCell& Multiply(const mpq_class& coeff);
  ExpressionCell& Divide(const mpq_class& coeff);

  template <MapFromTo<Variable, mpq_class> T>
  [[nodiscard]] mpq_class Evaluate(const T& env = {}) const;

  [[nodiscard]] Expression Substitute(const SubstitutionMap& s) const;
 
  std::ostream& Print(std::ostream& os) const;
  static std::ostream& PrintAddend(std::ostream& os, bool print_plus, const Variable& var, const mpq_class& coeff);
 
  static intrusive_ptr<ExpressionCell> New();
  static intrusive_ptr<ExpressionCell> New(Variable var);
  static intrusive_ptr<ExpressionCell> New(Addend linear_monomial);
  static intrusive_ptr<ExpressionCell> New(Addends addends);
  static intrusive_ptr<ExpressionCell> Copy(const ExpressionCell& o);
 
 protected:
  ExpressionCell() = default;
  explicit ExpressionCell(Variable var);
  explicit ExpressionCell(Addend linear_monomial);
  explicit ExpressionCell(Addends addends);
 
  mutable std::size_t hash_;     
  Expression::Addends addends_;  
};
 
}  // namespace delpi