MatrixIO.h

Go to the documentation of this file.

#ifndef MATRIXIO_H
#define MATRIXIO_H
#pragma once
 
#include "txeo/Logger.h"
#include "txeo/LoggerConsole.h"
#include "txeo/Matrix.h"
 
#include <cstddef>
#include <filesystem>
#include <map>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <utility>
 
namespace txeo {
 
class MatrixIO {
  public:
    explicit MatrixIO(const std::filesystem::path &path, char separator = ',',
                      txeo::Logger &logger = txeo::LoggerConsole::instance())
        : _path(std::move(path)), _separator(separator), _logger{&logger} {};
 
    [[nodiscard]] std::filesystem::path path() const { return _path; }
 
    [[nodiscard]] char separator() const { return _separator; }
 
    template <typename T>
    txeo::Matrix<T> read_text_file(bool has_header = false) const;
 
    template <typename T>
    void write_text_file(const txeo::Matrix<T> &matrix) const;
 
    template <typename T>
      requires(std::is_floating_point_v<T>)
    void write_text_file(const txeo::Matrix<T> &matrix, size_t precision) const;
 
    template <typename T>
    static txeo::Matrix<T> read_textfile(const std::filesystem::path &path, char separator = ',',
                                         bool has_header = false) {
      txeo::MatrixIO io{path, separator};
      Matrix<T> resp{io.read_text_file<T>(has_header)};
      return resp;
    };
 
    template <typename T>
    static void write_textfile(const txeo::Matrix<T> &matrix, const std::filesystem::path &path,
                               char separator = ',') {
      txeo::MatrixIO io{path, separator};
      io.write_text_file(matrix);
    }
 
    template <typename T>
      requires(std::is_floating_point_v<T>)
    static void write_textfile(const txeo::Matrix<T> &matrix, size_t precision,
                               const std::filesystem::path &path, char separator = ',') {
      txeo::MatrixIO io{path, separator};
      io.write_text_file(matrix, precision);
    };
 
    static txeo::MatrixIO
    one_hot_encode_text_file(const std::filesystem::path &source_path, char separator,
                             bool has_header, const std::filesystem::path &target_path,
                             txeo::Logger &logger = txeo::LoggerConsole::instance());
 
  private:
    std::filesystem::path _path;
    char _separator;
    txeo::Logger *_logger{nullptr};
 
    static std::map<size_t, std::unordered_set<std::string>>
    build_lookups_map(const std::filesystem::path &source_path, char separator, bool has_header);
 
    static std::string
    build_target_header(const std::filesystem::path &source_path, char separator, bool has_header,
                        const std::map<size_t, std::unordered_set<std::string>> &lookups_map);
};
 
class MatrixIOError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
} // namespace txeo
 
#endif