expression_cell.h

 
#pragma once
 
#include <map>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <unordered_map>
#include <utility>
 
#include "smats/symbolic/environment.h"
#include "smats/symbolic/expression.h"
#include "smats/symbolic/expression_kind.h"
#include "smats/symbolic/variable.h"
#include "smats/symbolic/variables.h"
#include "smats/util/definitions.h"
#include "smats/util/hash.hpp"
 
namespace smats {
 
template <class T>
using Substitution = std::unordered_map<Variable, Expression<T>>;
 
#define PARAMS(...) __VA_ARGS__
#define NEW_OPERATOR(class_name)                                                         \
  static std::shared_ptr<const class_name<T>> New() {                                    \
    return std::make_shared<const class_name<T>>(typename ExpressionCell<T>::Private()); \
  }                                                                                      \
  explicit class_name(typename ExpressionCell<T>::Private)
 
#define NEW_OPERATOR_PARAMS(class_name, params, args)                                          \
  static std::shared_ptr<const class_name<T>> New(params) {                                    \
    return std::make_shared<const class_name<T>>(typename ExpressionCell<T>::Private(), args); \
  }                                                                                            \
  class_name(typename ExpressionCell<T>::Private, params)
 
template <class T>
class ExpressionCell : public std::enable_shared_from_this<ExpressionCell<T>> {
 public:
  ExpressionCell() = delete;
  virtual ~ExpressionCell() = default;
 
  [[nodiscard]] long use_count() const {
    return std::enable_shared_from_this<ExpressionCell<T>>::shared_from_this().use_count();
  }
 
  [[nodiscard]] ExpressionKind kind() const { return kind_; }
 
  virtual void hash(DelegatingHasher&) const = 0;
 
  [[nodiscard]] const Variables& variables() const;
 
  [[nodiscard]] bool is_polynomial() const;
 
  [[nodiscard]] bool is_expanded() const { return is_expanded_; }
 
  [[nodiscard]] virtual bool equal_to(const ExpressionCell<T>& o) const = 0;
 
  [[nodiscard]] virtual bool less(const ExpressionCell<T>& o) const = 0;
 
  void set_expanded() { is_expanded_ = true; }
 
  template <template <class> class E>
  [[nodiscard]] const E<T>& to() const {
#ifndef NDEBUG
    if (kind() != E<T>::expression_kind) throw std::runtime_error("ExpressionCell::to(): invalid cast");
#endif
    return static_cast<const E<T>&>(*this);
  }
  template <template <class> class E>
  [[nodiscard]] E<T>& to() {
#ifndef NDEBUG
    if (kind() != E<T>::expression_kind) throw std::runtime_error("ExpressionCell::to(): invalid cast");
#endif
    return static_cast<E<T>&>(*this);
  }
 
  [[nodiscard]] Expression<T> to_expression() const {
    return Expression{std::enable_shared_from_this<ExpressionCell<T>>::shared_from_this()};
  }
 
  [[nodiscard]] virtual T evaluate(const Environment<T>& env) const = 0;
 
  [[nodiscard]] virtual Expression<T> expand() const = 0;
 
  [[nodiscard]] virtual Expression<T> evaluate_partial(const Environment<T>& env) const = 0;
 
  [[nodiscard]] virtual Expression<T> substitute(const Substitution<T>& s) const = 0;
 
  [[nodiscard]] virtual Expression<T> differentiate(const Variable& x) const = 0;
 
  virtual std::ostream& display(std::ostream& os) const = 0;
 
  void invalidate_cache();
 
 protected:
  struct Private {};
  ExpressionCell(ExpressionKind kind, bool is_expanded);
  ExpressionCell(ExpressionKind kind, bool is_polynomial, bool is_expanded);
 
  virtual void compute_variables(std::optional<Variables>& variables) const = 0;
  virtual void compute_is_polynomial(std::optional<bool>& is_polynomial) const = 0;
 
 private:
  const ExpressionKind kind_;                   
  mutable std::optional<Variables> variables_;  
  mutable std::optional<bool> is_polynomial_;   
  bool is_expanded_{false};                     
};
 
template <class T>
class UnaryExpressionCell : public ExpressionCell<T> {
 public:
  [[nodiscard]] const Expression<T>& get_argument() const { return e_; }
 
 protected:
  UnaryExpressionCell(ExpressionKind k, Expression<T> e, bool is_expanded);
  UnaryExpressionCell(ExpressionKind k, Expression<T> e, bool is_polynomial, bool is_expanded);
  [[nodiscard]] virtual T do_evaluate(T v) const = 0;
 
 private:
  const Expression<T> e_;  
};
 
template <class T>
class BinaryExpressionCell : public ExpressionCell<T> {
 public:
  void hash(DelegatingHasher& hasher) const override;
  [[nodiscard]] bool equal_to(const ExpressionCell<T>& o) const override;
  [[nodiscard]] bool less(const ExpressionCell<T>& o) const override;
  [[nodiscard]] T evaluate(const Environment<T>& env) const override;
  [[nodiscard]] const Expression<T>& lhs() const { return e1_; }
  [[nodiscard]] const Expression<T>& rhs() const { return e2_; }
 
 protected:
  BinaryExpressionCell(ExpressionKind kind, Expression<T> e1, Expression<T> e2, bool is_expanded);
  [[nodiscard]] virtual T do_evaluate(const T& v1, const T& v2) const = 0;
 
  void compute_variables(std::optional<Variables>& variables) const override;
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
 
 private:
  const Expression<T> e1_;  
  const Expression<T> e2_;  
};
 
template <class T>
class ExpressionConstant : public ExpressionCell<T> {
 public:
  static const ExpressionKind expression_kind = ExpressionKind::Constant;
 
  NEW_OPERATOR_PARAMS(ExpressionConstant, const T& constant, constant);
 
  [[nodiscard]] const T& value() const { return value_; }
  T& m_value();
 
  void hash(DelegatingHasher& hasher) const override;
  [[nodiscard]] bool equal_to(const ExpressionCell<T>& o) const override;
  [[nodiscard]] bool less(const ExpressionCell<T>& o) const override;
 
  [[nodiscard]] T evaluate(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> expand() const override;
  [[nodiscard]] Expression<T> evaluate_partial(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> substitute(const Substitution<T>& s) const override;
  [[nodiscard]] Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
 
 private:
  const T value_;  
 
  void compute_variables(std::optional<Variables>& variables) const override;
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
};
 
template <class T>
class ExpressionVar : public ExpressionCell<T> {
 public:
  static const ExpressionKind expression_kind = ExpressionKind::Var;
 
  NEW_OPERATOR_PARAMS(ExpressionVar, Variable v, v);
 
  [[nodiscard]] const Variable& variable() const { return var_; }
 
  void hash(DelegatingHasher& hasher) const override;
  [[nodiscard]] bool equal_to(const ExpressionCell<T>& o) const override;
  [[nodiscard]] bool less(const ExpressionCell<T>& o) const override;
 
  [[nodiscard]] T evaluate(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> expand() const override;
  [[nodiscard]] Expression<T> evaluate_partial(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> substitute(const Substitution<T>& s) const override;
  [[nodiscard]] Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
 
 private:
  const Variable var_;  
 
  void compute_variables(std::optional<Variables>& variables) const override;
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
};
 
template <class T>
class ExpressionNaN : public ExpressionCell<T> {
 public:
  static const ExpressionKind expression_kind = ExpressionKind::NaN;
 
  NEW_OPERATOR(ExpressionNaN);
 
  void hash(DelegatingHasher& hasher) const override;
  [[nodiscard]] bool equal_to(const ExpressionCell<T>& o) const override;
  [[nodiscard]] bool less(const ExpressionCell<T>& o) const override;
  [[nodiscard]] T evaluate(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> expand() const override;
  [[nodiscard]] Expression<T> evaluate_partial(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> substitute(const Substitution<T>& s) const override;
  [[nodiscard]] Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
 
 private:
  void compute_variables(std::optional<Variables>& variables) const override;
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
};
 
template <class T>
class ExpressionAdd : public ExpressionCell<T> {
 public:
  using ExpressionMap = std::map<Expression<T>, T>;
  static const ExpressionKind expression_kind = ExpressionKind::Add;
 
  NEW_OPERATOR_PARAMS(ExpressionAdd, PARAMS(T constant, ExpressionMap expr_to_coeff_map),
                      PARAMS(constant, expr_to_coeff_map));
 
  void hash(DelegatingHasher&) const override;
  [[nodiscard]] bool equal_to(const ExpressionCell<T>& o) const override;
  [[nodiscard]] bool less(const ExpressionCell<T>& o) const override;
  [[nodiscard]] T evaluate(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> evaluate_partial(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> expand() const override;
  [[nodiscard]] Expression<T> substitute(const Substitution<T>& s) const override;
  [[nodiscard]] Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
  [[nodiscard]] const T& constant() const { return constant_; }
  T& m_constant();
 
  [[nodiscard]] const ExpressionMap& expr_to_coeff_map() const { return expr_to_coeff_map_; }
  ExpressionMap& m_expr_to_coeff_map();
 
 private:
  static Variables extract_variables(const ExpressionMap& expr_to_coeff_map);
 
  const T constant_;                       
  const ExpressionMap expr_to_coeff_map_;  
 
  void compute_variables(std::optional<Variables>& variables) const override;
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
  std::ostream& display_term(std::ostream& os, bool print_plus, const T& coeff, const Expression<T>& term) const;
};
 
template <class T>
class ExpressionMul : public ExpressionCell<T> {
 public:
  using ExpressionMap = std::map<Expression<T>, Expression<T>>;
  static const ExpressionKind expression_kind = ExpressionKind::Mul;
 
  NEW_OPERATOR_PARAMS(ExpressionMul, PARAMS(T constant, ExpressionMap expr_to_coeff_map),
                      PARAMS(constant, expr_to_coeff_map));
 
  void hash(DelegatingHasher&) const override;
  [[nodiscard]] bool equal_to(const ExpressionCell<T>& o) const override;
  [[nodiscard]] bool less(const ExpressionCell<T>& o) const override;
  [[nodiscard]] T evaluate(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> evaluate_partial(const Environment<T>& env) const override;
  [[nodiscard]] Expression<T> expand() const override;
  [[nodiscard]] Expression<T> substitute(const Substitution<T>& s) const override;
  [[nodiscard]] Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
  [[nodiscard]] const T& constant() const { return constant_; }
  T& m_constant();
 
  [[nodiscard]] const ExpressionMap& base_to_exponent_map() const { return base_to_exponent_map_; }
  ExpressionMap& m_base_to_exponent_map();
 
 private:
  static Variables extract_variables(const ExpressionMap& base_to_exponent_map);
 
  const T constant_;                          
  const ExpressionMap base_to_exponent_map_;  
 
  void compute_variables(std::optional<Variables>& variables) const override;
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
 
  std::ostream& display_term(std::ostream& os, bool print_mul, const Expression<T>& base,
                             const Expression<T>& exponent) const;
};
 
template <class T>
class ExpressionPow : public BinaryExpressionCell<T> {
 public:
  static const ExpressionKind expression_kind = ExpressionKind::Pow;
  static void check_domain(const T& v1, const T& v2);
 
  NEW_OPERATOR_PARAMS(ExpressionPow, PARAMS(const Expression<T>& e1, const Expression<T>& e2), PARAMS(e1, e2));
 
  Expression<T> evaluate_partial(const Environment<T>& env) const override;
  Expression<T> expand() const override;
  Expression<T> substitute(const Substitution<T>& s) const override;
  Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
 
 private:
  T do_evaluate(const T& v1, const T& v2) const override;
 
  void compute_is_polynomial(std::optional<bool>& is_polynomial) const override;
};
 
template <class T>
class ExpressionDiv : public BinaryExpressionCell<T> {
 public:
  static const ExpressionKind expression_kind = ExpressionKind::Div;
  static void check_domain(const T& v1, const T& v2);
 
  NEW_OPERATOR_PARAMS(ExpressionDiv, PARAMS(const Expression<T>& e1, const Expression<T>& e2), PARAMS(e1, e2));
 
  Expression<T> expand() const override;
  Expression<T> evaluate_partial(const Environment<T>& env) const override;
  Expression<T> substitute(const Substitution<T>& s) const override;
  Expression<T> differentiate(const Variable& x) const override;
  std::ostream& display(std::ostream& os) const override;
 
 private:
  T do_evaluate(const T& v1, const T& v2) const override;
};
 
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionCell);
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionConstant);
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionVar);
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionNaN);
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionAdd);
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionMul);
// EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(ExpressionPow);
 
}  // namespace smats