columns_info.h

Go to the documentation of this file.

 
#if !defined(ULTRA_COLUMNS_INFO_H)
#define      ULTRA_COLUMNS_INFO_H
 
#include "kernel/symbol.h"
#include "kernel/value.h"
#include "utility/misc.h"
 
#include <algorithm>
#include <functional>
#include <iostream>
#include <optional>
#include <random>
#include <set>
#include <string>
#include <vector>
 
namespace ultra::src
{

enum class typing {weak, strong};

enum class task_t {classification, regression, unsupervised};

template<class R>
concept DataframeRow =
  std::ranges::forward_range<R>
  && std::ranges::sized_range<R>
  && std::copyable<R>
  && (std::same_as<std::ranges::range_value_t<R>, value_t>
      || std::same_as<std::ranges::range_value_t<R>, std::string>);

template<class R> concept DataframeMatrix =
  std::ranges::forward_range<R>
  && std::ranges::sized_range<R>
  && DataframeRow<std::ranges::range_value_t<R>>;

class columns_info
{
public:
  class column_info
  {
  public:
    explicit column_info(const columns_info &,
                         std::string_view = "",
                         domain_t = d_void,
                         const std::set<value_t> & = {});
 
    [[nodiscard]] const std::string &name() const noexcept;
    void name(const std::string &);
 
    [[nodiscard]] domain_t domain() const noexcept;
    void domain(domain_t);
 
    [[nodiscard]] const std::set<value_t> &states() const noexcept;
    void add_state(value_t);
 
    [[nodiscard]] symbol::category_t category() const;
 
  private:
    const columns_info *owner_ {nullptr};
 
    std::string         name_;
    domain_t          domain_;
    std::set<value_t> states_;
  };
 
  // ---- Aliases ----
  using const_iterator = std::vector<column_info>::const_iterator;
  using iterator = std::vector<column_info>::iterator;
  using size_type = std::size_t;
  using value_type = column_info;
 
  // ---- Constructors ----
  columns_info() = default;
  columns_info(const columns_info &);
  columns_info(const std::vector<std::pair<std::string, domain_t>> &);
 
  columns_info &operator=(const columns_info &);
 
  // ---- Element access ----
  [[nodiscard]] const column_info &operator[](size_type) const;
  [[nodiscard]] column_info &operator[](size_type);
 
  [[nodiscard]] const column_info &operator[](const std::string &) const;
 
  [[nodiscard]] const column_info &front() const;
  [[nodiscard]] column_info &front();
 
  [[nodiscard]] const column_info &back() const;
  [[nodiscard]] column_info &back();
 
  // ---- Capacity ----
  [[nodiscard]] size_type size() const noexcept;
  [[nodiscard]] bool empty() const noexcept;
 
  // ---- Iterators ----
  [[nodiscard]] const_iterator begin() const noexcept;
  [[nodiscard]] iterator begin() noexcept;
  [[nodiscard]] const_iterator end() const noexcept;
  [[nodiscard]] iterator end() noexcept;
  [[nodiscard]] const_iterator cbegin() const noexcept;
  [[nodiscard]] const_iterator cend() const noexcept;
 
  // ---- Modifiers ----
  void pop_back();
  void push_back(const column_info &);
  void push_front(const column_info &);
 
  // ---- Misc ----
  void data_typing(typing) noexcept;
 
  template<DataframeMatrix R>
  void build(const R &, std::optional<std::size_t>);
 
  std::set<symbol::category_t> used_categories() const;
 
  [[nodiscard]] domain_t domain_of_category(symbol::category_t) const;
 
  [[nodiscard]] task_t task() const noexcept;
 
  [[nodiscard]] bool is_valid() const;
 
private:
  [[nodiscard]] symbol::category_t category(const column_info &) const;
  [[nodiscard]] domain_t evaluation_domain(const column_info &) const;
  void settle_task_t();
 
  std::vector<column_info> cols_ {};
  typing typing_ {typing::weak};
 
  task_t task_ {task_t::regression};
};
 
#include "columns_info.tcc"
 
}  // namespace ultra::src
 
#endif  // include guard