dataframe.h

Go to the documentation of this file.

 
#if !defined(ULTRA_DATAFRAME_H)
#define      ULTRA_DATAFRAME_H
 
#include "kernel/distribution.h"
#include "kernel/exceptions.h"
#include "kernel/problem.h"
#include "kernel/gp/src/classification_result.h"
#include "kernel/gp/src/columns_info.h"
#include "utility/pocket_csv.h"
 
#include <filesystem>
#include <functional>
#include <map>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
namespace tinyxml2 { class XMLDocument; }
 
namespace ultra::src
{

using record_t = std::vector<value_t>;
 
using raw_data = std::vector<record_t>;

struct example
{
  value_t output {};
  std::vector<value_t> input {};
 
  [[nodiscard]] bool operator==(const example &) const noexcept = default;
};
 
[[nodiscard]] class_t label(const src::example &);

class dataframe
{
public:
  // ---- Structures ----
  struct params;
 
  // ---- Aliases ----
  using examples_t = std::vector<src::example>;
  using value_type = examples_t::value_type;
 
  // ---- Constructors ----
  dataframe() = default;
  explicit dataframe(std::istream &);
  dataframe(std::istream &, const params &);
  explicit dataframe(const std::filesystem::path &);
  dataframe(const std::filesystem::path &, const params &);
  template<DataframeMatrix R> dataframe(const R &);
  template<DataframeMatrix R> dataframe(const R &, params);
 
  // ---- Iterators ----
  using iterator = examples_t::iterator;
  using const_iterator = examples_t::const_iterator;
  using difference_type = examples_t::difference_type;
 
  [[nodiscard]] iterator begin() noexcept;
  [[nodiscard]] const_iterator begin() const noexcept;
  [[nodiscard]] iterator end() noexcept;
  [[nodiscard]] const_iterator end() const noexcept;
 
  // ---- Element access ----
  [[nodiscard]] const value_type &front() const;
  [[nodiscard]] value_type &front();
 
  // ---- Modifiers ----
  void clear();
  iterator erase(iterator, iterator);
  void push_back(src::example, bool = false);
  template<std::input_iterator InputIt> iterator insert(const_iterator,
                                                        InputIt, InputIt);
  void swap(dataframe &);
 
  // ---- Convenience ----
  std::size_t read(const std::filesystem::path &);
  std::size_t read(const std::filesystem::path &, const params &);
  std::size_t read(std::istream &);
  std::size_t read(std::istream &, params);
  template<DataframeMatrix R> std::size_t read(const R &);
  template<DataframeMatrix R> std::size_t read(const R &, params);
  [[nodiscard]] bool operator!() const noexcept;
 
  bool clone_schema(const dataframe &);
  bool set_schema(const std::vector<std::pair<std::string, domain_t>> &);
 
  // ---- Capacity ----
  [[nodiscard]] std::size_t size() const noexcept;
  [[nodiscard]] bool empty() const noexcept;
 
  [[nodiscard]] class_t classes() const noexcept;
  [[nodiscard]] unsigned variables() const;
 
  // ---- Misc ----
  [[nodiscard]] std::string class_name(class_t) const noexcept;
  [[nodiscard]] task_t task() const noexcept;
 
  [[nodiscard]] bool is_valid() const;
 
  // ---- Public data members ----
  src::columns_info columns {};
 
private:
  template<DataframeRow R> bool read_record(R, std::optional<std::size_t>,
                                            bool);
 
  template<std::ranges::range R>
  [[nodiscard]] example to_example(const R &) const;
 
  [[nodiscard]] class_t encode(const value_t &);
 
  std::size_t read_csv(const std::filesystem::path &, const params &);
  std::size_t read_csv(std::istream &);
  std::size_t read_csv(std::istream &, params);
 
  std::size_t read_xrff(const std::filesystem::path &, const params &);
  std::size_t read_xrff(std::istream &, params);
  std::size_t read_xrff(tinyxml2::XMLDocument &, const params &);
 
  // Integer are simpler to manage than textual data, so, when appropriate,
  // input strings are converted into integers by this map and the `encode`
  // static function.
  std::map<std::string, class_t> classes_map_ {};
 
  // Available data.
  examples_t dataset_ {};
};
 
[[nodiscard]] domain_t from_weka(const std::string &);

///
///
template<class T>
[[nodiscard]] T label_as(const src::example &e)
{
  return lexical_cast<T>(e.output);
}
 
struct dataframe::params
{
  enum index : std::size_t {front = 0,
                            back = std::numeric_limits<std::size_t>::max() };

  typing data_typing {typing::weak};

  /// \remark
  /// Used only when reading CSV files.
  pocket_csv::dialect dialect {};


  pocket_csv::parser::filter_hook_t filter {nullptr};

  std::optional<std::size_t> output_index {0};
 
  params &header() noexcept
  { dialect.has_header = pocket_csv::dialect::HAS_HEADER; return *this; }
  params &no_header() noexcept
  { dialect.has_header = pocket_csv::dialect::NO_HEADER; return *this; }
 
  params &output(std::size_t o) { output_index = o; return *this; }
  params &no_output() noexcept { output_index = std::nullopt; return *this; }
 
  params &strong_data_typing() noexcept
  { data_typing = typing::strong; return *this; }
  params &weak_data_typing() noexcept
  { data_typing = typing::weak; return *this; }
};
 
std::ostream &operator<<(std::ostream &, const dataframe &);

template<std::input_iterator InputIt>
dataframe::iterator dataframe::insert(dataframe::const_iterator pos,
                                      InputIt first, InputIt last)
{
  return dataset_.insert(pos, first, last);
}
 
#include "kernel/gp/src/dataframe.tcc"
 
}  // namespace ultra::src
 
#endif  // include guard