expression.h

 
#pragma once
 
#include <algorithm>  // for cpplint only
#include <cmath>
#include <cstddef>
#include <functional>
#include <limits>
#include <map>
#include <memory>
#include <numbers>
#include <ostream>
#include <random>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "smats/symbolic/environment.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>
class ExpressionCell;  // In expression_cell.h
template <class T>
class ExpressionVar;  // In expression_cell.h
template <class T>
class UnaryExpressionCell;  // In expression_cell.h
template <class T>
class BinaryExpressionCell;  // In expression_cell.h
template <class T>
class ExpressionAdd;  // In expression_cell.h
template <class T>
class ExpressionMul;  // In expression_cell.h
template <class T>
class ExpressionDiv;  // In expression_cell.h
template <class T>
class ExpressionLog;  // In expression_cell.h
template <class T>
class ExpressionAbs;  // In expression_cell.h
template <class T>
class ExpressionExp;  // In expression_cell.h
template <class T>
class ExpressionSqrt;  // In expression_cell.h
template <class T>
class ExpressionPow;  // In expression_cell.h
template <class T>
class ExpressionSin;  // In expression_cell.h
template <class T>
class ExpressionCos;  // In expression_cell.h
template <class T>
class ExpressionTan;  // In expression_cell.h
template <class T>
class ExpressionAsin;  // In expression_cell.h
template <class T>
class ExpressionAcos;  // In expression_cell.h
template <class T>
class ExpressionAtan;  // In expression_cell.h
template <class T>
class ExpressionAtan2;  // In expression_cell.h
template <class T>
class ExpressionSinh;  // In expression_cell.h
template <class T>
class ExpressionCosh;  // In expression_cell.h
template <class T>
class ExpressionTanh;  // In expression_cell.h
template <class T>
class ExpressionMin;  // In expression_cell.h
template <class T>
class ExpressionMax;  // In expression_cell.h
template <class T>
class ExpressionCeiling;  // In expression_cell.h
template <class T>
class ExpressionFloor;  // In expression_cell.h
template <class T>
class ExpressionIfThenElse;  // In expression_cell.h
template <class T>
class ExpressionUninterpretedFunction;  // In expression_cell.h
template <class T>
class Formula;  // In formula.h
template <class T>
class ExpressionAddFactory;  // In expression_factory.h
template <class T>
class ExpressionMulFactory;  // In expression_factory.h
 
template <class T>
class Expression {
  friend class ExpressionCell<T>;
  friend class ExpressionAddFactory<T>;
  friend class ExpressionMulFactory<T>;
 
 public:
  static Expression<T> zero();
  static Expression<T> one();
  static Expression<T> pi() {
    static Expression pi{static_cast<T>(std::numbers::pi)};
    return pi;
  }
  static Expression<T> e() {
    static Expression e{static_cast<T>(std::numbers::e)};
    return e;
  }
  static Expression<T> NaN();
 
  Expression();
  Expression(const T& constant);  // NOLINT (runtime/explicit): This conversion is desirable.
  Expression(const Variable& var);  // NOLINT (runtime/explicit): This conversion is desirable.
 
  [[nodiscard]] ExpressionKind kind() const;
 
  [[nodiscard]] Variables variables() const;
 
  [[nodiscard]] bool equal_to(const Expression<T>& e) const;
 
  [[nodiscard]] bool less(const Expression<T>& e) const;
 
  [[nodiscard]] bool is_polynomial() const;
 
  [[nodiscard]] T evaluate(const Environment<T>& env = {}) const;
 
  [[nodiscard]] Expression<T> evaluate_partial(const Environment<T>& env) const;
 
  [[nodiscard]] bool is_expanded() const;
 
  [[nodiscard]] Expression<T> expand() const;
 
  [[nodiscard]] Expression<T> substitute(const Variable& var, const Expression<T>& e) const;
 
  [[nodiscard]] Expression<T> substitute(const std::unordered_map<Variable, Expression<T>>& s) const;
 
  [[nodiscard]] Expression<T> differentiate(const Variable& x) const;
 
  [[nodiscard]] std::string to_string() const;
 
  void hash(InvocableHashAlgorithm auto& hasher) const noexcept { cell_->hash(hasher); }
 
  ARITHMETIC_OPERATORS(Expression<T>)
  GENERIC_ARITHMETIC_OPERATORS(Expression<T>, T&)
  GENERIC_ARITHMETIC_OPERATORS(Expression<T>, Variable&)
  Expression<T> operator-() const;
  Expression<T>& operator++();
  Expression<T> operator++(int);
  Expression<T>& operator--();
  Expression<T> operator--(int);
  Expression<T>& operator^=(const Expression<T>& o);
  Expression<T> operator^(const Expression<T>& o) const;
 
  // Cast functions which takes a pointer to a non-const Expression.
  [[nodiscard]] bool is_leaf() const;
  [[nodiscard]] bool is_constant() const;
  [[nodiscard]] bool is_constant(const T& value) const;
  [[nodiscard]] bool is_variable() const;
  [[nodiscard]] bool is_variable(const Variable& var) const;
  [[nodiscard]] bool is_addition() const;
  [[nodiscard]] bool is_multiplication() const;
  [[nodiscard]] bool is_division() const;
  [[nodiscard]] bool is_nan() const;
  [[nodiscard]] bool is_pow() const;
  template <ExpressionKind K>
  [[nodiscard]] bool is() const {
    return cell_->kind() == K;
  }
 
  [[nodiscard]] const T& constant() const;
  [[nodiscard]] const std::map<Expression<T>, T>& expression_to_coeff_map() const;
  [[nodiscard]] const std::map<Expression<T>, Expression<T>>& base_to_exponent_map() const;
  [[nodiscard]] const Expression<T>& lhs() const;
  [[nodiscard]] const Expression<T>& rhs() const;
 
  [[nodiscard]] long use_count() const { return cell_.use_count(); }
 
 private:
  explicit Expression(const std::shared_ptr<const ExpressionCell<T>>& cell, bool is_expanded = false);
 
  [[nodiscard]] const ExpressionCell<T>& cell() const { return *cell_; }
  [[nodiscard]] ExpressionCell<T>& m_cell();
 
  std::shared_ptr<const ExpressionCell<T>> cell_;
};
 
template <class T>
Expression<T> operator+(const T& c, const Expression<T>& e);
template <class T>
Expression<T> operator-(const T& c, const Expression<T>& e);
template <class T>
Expression<T> operator*(const T& c, const Expression<T>& e);
template <class T>
Expression<T> operator/(const T& c, const Expression<T>& e);
template <class T>
Expression<T> operator^(const T& c, const Expression<T>& e);
 
template <class T>
std::ostream& operator<<(std::ostream& os, const Expression<T>& e);
 
EXTERNAL_TEMPLATE_INSTANTIATION_NUMERIC(Expression);
 
using ExpressionD = Expression<double>;
using ExpressionF = Expression<float>;
using ExpressionI = Expression<int>;
using ExpressionL = Expression<long>;
 
}  // namespace smats
 
namespace std {
 
/* Provides std::hash<smats::Expression>. */
template <class T>
struct hash<smats::Expression<T>> : public smats::DefaultHash {};
 
/* Provides std::less<smats::Expression>. */
template <class T>
struct less<smats::Expression<T>> {
  bool operator()(const smats::Expression<T>& lhs, const smats::Expression<T>& rhs) const { return lhs.less(rhs); }
};
 
/* Provides std::equal_to<smats::Expression>. */
template <class T>
struct equal_to<smats::Expression<T>> {
  bool operator()(const smats::Expression<T>& lhs, const smats::Expression<T>& rhs) const { return lhs.equal_to(rhs); }
};
 
}  // namespace std