/opt/build/repo/include/txeo/DataTable.h

Construct a DataTable with explicit training/evaluation/test splits.

Construct a DataTable with explicit training/evaluation/test splits.

Parameters

x_train	Training input matrix (features)
y_train	Training output matrix (labels)
x_eval	Evaluation input matrix (features)
y_eval	Evaluation output matrix (labels)
x_test	Test input matrix (features)
y_test	Test output matrix (labels)

txeo::Matrix<double> X_train = {{1.0, 2.0}, {3.0, 4.0}};
txeo::Matrix<double> y_train = {{0.5}, {1.2}};
txeo::Matrix<double> X_eval = {{5.0, 6.0}};
txeo::Matrix<double> y_eval = {{2.1}};
txeo::Matrix<double> X_test = {{7.0, 8.0}};
txeo::Matrix<double> y_test = {{3.0}};
 
// Create dataset with pre-split data
DataTable<double> dt_full(X_train, y_train, X_eval, y_eval, X_test, y_test);

#ifndef DATATABLE_H
#define DATATABLE_H
#pragma once
 
#include "txeo/Matrix.h"
 
#include <cstddef>
#include <stdexcept>
#include <vector>
 
namespace txeo {
 
template <typename T>
class DataTable {
  public:
    ~DataTable() = default;
 
    DataTable(const DataTable &) = default;
    DataTable(DataTable &&) = default;
    DataTable &operator=(const DataTable &) = default;
    DataTable &operator=(DataTable &&) = default;
 
    DataTable(txeo::Matrix<T> &&data, std::vector<size_t> x_cols, std::vector<size_t> y_cols);
 
    DataTable(const txeo::Matrix<T> &data, std::vector<size_t> x_cols, std::vector<size_t> y_cols)
        : DataTable{std::move(data.clone()), x_cols, y_cols} {};
 
    DataTable(txeo::Matrix<T> &&data, std::vector<size_t> y_cols);
 
    DataTable(const txeo::Matrix<T> &data, std::vector<size_t> y_cols)
        : DataTable{std::move(data.clone()), y_cols} {};
 
    DataTable(txeo::Matrix<T> &&data, std::vector<size_t> x_cols, std::vector<size_t> y_cols,
              size_t eval_percent);
 
    DataTable(const txeo::Matrix<T> &data, std::vector<size_t> x_cols, std::vector<size_t> y_cols,
              size_t eval_percent)
        : DataTable{std::move(data.clone()), x_cols, y_cols, eval_percent} {};
 
    DataTable(txeo::Matrix<T> &&data, std::vector<size_t> y_cols, size_t eval_percent);
 
    DataTable(const txeo::Matrix<T> &data, std::vector<size_t> y_cols, size_t eval_percent)
        : DataTable{std::move(data.clone()), y_cols, eval_percent} {};
 
    DataTable(txeo::Matrix<T> &&data, std::vector<size_t> x_cols, std::vector<size_t> y_cols,
              size_t eval_percent, size_t eval_test);
 
    DataTable(const txeo::Matrix<T> &data, std::vector<size_t> x_cols, std::vector<size_t> y_cols,
              size_t eval_percent, size_t eval_test)
        : DataTable{std::move(data.clone()), x_cols, y_cols, eval_percent, eval_test} {};
 
    DataTable(txeo::Matrix<T> &&data, std::vector<size_t> y_cols, size_t eval_percent,
              size_t eval_test);
 
    DataTable(const txeo::Matrix<T> &data, std::vector<size_t> y_cols, size_t eval_percent,
              size_t eval_test)
        : DataTable<T>{std::move(data.clone()), y_cols, eval_percent, eval_test} {};
 
    DataTable(txeo::Matrix<T> &&x_train, txeo::Matrix<T> &&y_train, txeo::Matrix<T> &&x_eval,
              txeo::Matrix<T> &&y_eval, txeo::Matrix<T> &&x_test, txeo::Matrix<T> &&y_test);
 
    DataTable(const txeo::Matrix<T> &x_train, const txeo::Matrix<T> &y_train,
              const txeo::Matrix<T> &x_eval, const txeo::Matrix<T> &y_eval,
              const txeo::Matrix<T> &x_test, const txeo::Matrix<T> &y_test)
        : DataTable<T>{std::move(x_train.clone()), std::move(y_train.clone()),
                       std::move(x_eval.clone()),  std::move(y_eval.clone()),
                       std::move(x_test.clone()),  std::move(y_test.clone())} {};
 
    DataTable(txeo::Matrix<T> &&x_train, txeo::Matrix<T> &&y_train, txeo::Matrix<T> &&x_eval,
              txeo::Matrix<T> &&y_eval);
 
    DataTable(const txeo::Matrix<T> &x_train, const txeo::Matrix<T> &y_train,
              const txeo::Matrix<T> &x_eval, const txeo::Matrix<T> &y_eval)
        : DataTable(std::move(x_train.clone()), std::move(y_train.clone()),
                    std::move(x_eval.clone()), std::move(y_eval.clone())) {};
 
    DataTable(txeo::Matrix<T> &&x_train, txeo::Matrix<T> &&y_train);
 
    DataTable(const txeo::Matrix<T> &x_train, const txeo::Matrix<T> &y_train)
        : DataTable{std::move(x_train.clone()), std::move(y_train.clone())} {};
 
    const txeo::Matrix<T> &x_train() const { return _x_train; }
 
    const txeo::Matrix<T> &y_train() const { return _y_train; }
 
    const txeo::Matrix<T> *x_eval() const;
 
    const txeo::Matrix<T> *y_eval() const;
 
    const txeo::Matrix<T> *x_test() const;
 
    const txeo::Matrix<T> *y_test() const;
 
    [[nodiscard]] size_t x_dim() const;
 
    [[nodiscard]] size_t y_dim() const;
 
    [[nodiscard]] size_t row_size() const;
 
    [[nodiscard]] bool has_eval() const { return _has_eval; }
 
    [[nodiscard]] bool has_test() const { return _has_test; }
 
    DataTable<T> clone() const;
 
  private:
    DataTable() = default;
 
    txeo::Matrix<T> _x_train;
    txeo::Matrix<T> _y_train;
    txeo::Matrix<T> _x_eval;
    txeo::Matrix<T> _y_eval;
    txeo::Matrix<T> _x_test;
    txeo::Matrix<T> _y_test;
    bool _has_eval = false;
    bool _has_test = false;
};
 
class DataTableError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
} // namespace txeo
 
#endif