Expression.h

#pragma once
 
#include <cstddef>
#include <functional>
#include <map>
#include <memory>
#include <random>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "delpi/libs/gmp.h"
#include "delpi/symbolic/Variable.h"
#include "delpi/util/concepts.h"
#include "delpi/util/intrusive_ptr.hpp"
 
namespace delpi {
 
// Forward declaration. Found in "delpi/symbolic/ExpressionCell.h"
class ExpressionCell;

class Expression {
 public:
  using Addend = std::pair<Variable, mpq_class>;
  using Addends = std::map<Variable, mpq_class>;
  using SubstitutionMap = std::unordered_map<Variable, Variable>;

  Expression();
  Expression(Variable var);   // NOLINT (runtime/explicit): This conversion is desirable.
  Expression(Addend addend);  // NOLINT (runtime/explicit): This conversion is desirable.
  explicit Expression(Addends addends);
  explicit Expression(std::vector<Addend> addends);
  Expression(const Expression& e);
  Expression(Expression&& e) noexcept;
  Expression& operator=(const Expression& e);
  Expression& operator=(Expression&& e) noexcept;
  ~Expression();

  [[nodiscard]] std::vector<Variable> variables() const;
  [[nodiscard]] const Addends& addends() const;
  [[nodiscard]] std::size_t use_count() const;

  [[nodiscard]] bool equal_to(const Expression& o) const noexcept;
  [[nodiscard]] bool less(const Expression& o) const noexcept;
  [[nodiscard]] std::size_t hash() const noexcept;
  template <MapFromTo<Variable, mpq_class> T>
  [[nodiscard]] mpq_class Evaluate(const T& env = {}) const;

  [[nodiscard]] Expression Substitute(const SubstitutionMap& s) const;
  [[nodiscard]] std::string ToString() const;

  Expression& Add(const Variable& var, const mpq_class& coeff);
  Expression& Subtract(const Variable& var, const mpq_class& coeff);
 
  Expression operator-() const;
  Expression operator+() const;
 
  Expression& operator*=(const mpq_class& o);
  Expression& operator/=(const mpq_class& o);
  Expression operator*(const mpq_class& o) const;
  Expression operator/(const mpq_class& o) const;
 
  Expression& operator+=(const Variable& o);
  Expression& operator-=(const Variable& o);
  Expression operator+(const Variable& o) const;
  Expression operator-(const Variable& o) const;
  Expression& operator+=(const Addend& o);
  Expression& operator-=(const Addend& o);
  Expression operator+(const Addend& o) const;
  Expression operator-(const Addend& o) const;
  Expression& operator+=(const Expression& o);
  Expression& operator-=(const Expression& o);
  Expression operator+(const Expression& o) const;
  Expression operator-(const Expression& o) const;

  std::ostream& Print(std::ostream& os) const;
 
 private:
  intrusive_ptr<ExpressionCell> ptr_;  
};
 
Expression operator-(const Variable& var);
 
Expression operator*(const mpq_class& lhs, const Expression& rhs);
Expression operator*(const mpq_class& lhs, const Variable& rhs);
Expression operator*(const Variable& lhs, const mpq_class& rhs);
Expression operator/(const Variable& lhs, const mpq_class& rhs);
 
Expression operator+(const Variable& lhs, const Expression& rhs);
Expression operator-(const Variable& lhs, const Expression& rhs);
Expression operator+(const Expression::Addend& lhs, const Expression& rhs);
Expression operator-(const Expression::Addend& lhs, const Expression& rhs);
 
std::ostream& operator<<(std::ostream& os, const Expression& e);
 
}  // namespace delpi
 
/* Provides std::hash<smats::Expression>. */
template <>
struct std::hash<delpi::Expression> {
  size_t operator()(const delpi::Expression& e) const noexcept { return e.hash(); }
};
 
/* Provides std::less<smats::Expression>. */
template <>
struct std::less<delpi::Expression> {
  bool operator()(const delpi::Expression& lhs, const delpi::Expression& rhs) const noexcept { return lhs.less(rhs); }
};
 
/* Provides std::equal_to<smats::Expression>. */
template <>
struct std::equal_to<delpi::Expression> {
  bool operator()(const delpi::Expression& lhs, const delpi::Expression& rhs) const noexcept {
    return lhs.equal_to(rhs);
  }
};
 
#ifdef DELPI_INCLUDE_FMT
 
#include "delpi/util/logging.h"
 
OSTREAM_FORMATTER(delpi::Expression);
 
#endif