symbolic_variable.h

#pragma once
 
#include <cstddef>
#include <functional>
#include <memory>
#include <ostream>
#include <string>
 
#include "dlinear/symbolic/hash.h"
 
namespace dlinear::drake {
namespace symbolic {
 
class Variable {
 public:
  typedef size_t Id;
 
  enum class Type {
    CONTINUOUS,  
    INTEGER,     
    BINARY,      
    BOOLEAN,     
  };
 
  Variable(const Variable &) = default;
  Variable &operator=(const Variable &) = default;
  Variable(Variable &&) = default;
  Variable &operator=(Variable &&) = default;
 
  Variable() : id_{0}, type_{Type::CONTINUOUS} {}
 
  ~Variable() = default;
 
  explicit Variable(std::string name, Type type = Type::CONTINUOUS);
 
  bool is_dummy() const { return get_id() == 0; }
  Id get_id() const;
  Type get_type() const;
  size_t get_hash() const { return std::hash<Id>{}(id_); }
  std::string get_name() const;
  std::string to_string() const;
 
  bool equal_to(const Variable &v) const { return id_ == v.id_; }
 
  bool less(const Variable &v) const { return id_ < v.id_; }
 
  friend std::ostream &operator<<(std::ostream &os, const Variable &var);
 
 private:
  static std::vector<std::string> names_;  
  // Produces a unique ID for a variable.
  static Id get_next_id();
  Id id_{};                                      
  Type type_{Type::CONTINUOUS};                  
};
 
std::ostream &operator<<(std::ostream &os, Variable::Type type);
 
}  // namespace symbolic
 
}  // namespace dlinear::drake
 
namespace std {
/* Provides std::less<dlinear::drake::symbolic::Variable>. */
template <>
struct less<dlinear::drake::symbolic::Variable> {
  bool operator()(const dlinear::drake::symbolic::Variable &lhs, const dlinear::drake::symbolic::Variable &rhs) const {
    return lhs.less(rhs);
  }
};
 
/* Provides std::equal_to<dlinear::drake::symbolic::Variable>. */
template <>
struct equal_to<dlinear::drake::symbolic::Variable> {
  bool operator()(const dlinear::drake::symbolic::Variable &lhs, const dlinear::drake::symbolic::Variable &rhs) const {
    return lhs.equal_to(rhs);
  }
};
 
template <>
struct hash<dlinear::drake::symbolic::Variable> {
  size_t operator()(const dlinear::drake::symbolic::Variable &v) const { return v.get_hash(); }
};
 
}  // namespace std