data_table.h

Go to the documentation of this file.

 
#ifndef THEORETICA_IO_DATA_TABLE_H
#define THEORETICA_IO_DATA_TABLE_H
 
#include <map>
#include <vector>
#include <unordered_map>
#include <string>
#include <iomanip>
 
#include "../core/constants.h"
#include "../algebra/vec.h"
#include "../algebra/mat.h"
 
 
namespace theoretica {
 

    class data_table {
    private:
 
        // Vector of data columns.
        std::vector<vec<real>> columns {};
 
        // Ordered list of column names
        std::vector<std::string> column_names {};
 
        // Map of column names to their indices in the data table
        std::unordered_map<std::string, size_t> indices {};
 
    public:

        data_table() {}
 

        data_table(const std::map<std::string, vec<real>>& table) {
 
            for (const auto& pair : table) {
                column_names.emplace_back(pair.first);
                columns.emplace_back(pair.second);
                indices[pair.first] = columns.size() - 1;
            }
        }
        

        data_table(size_t num_rows, const std::vector<std::string>& column_names) {
 
            this->column_names = column_names;
            this->columns.resize(column_names.size(), vec<real>(num_rows));
 
            for (size_t i = 0; i < column_names.size(); ++i)
                indices[column_names[i]] = i;
        }
        

        data_table(const data_table& other) {
            columns = other.columns;
            column_names = other.column_names;
            indices = other.indices;
        }

        data_table(data_table&& other) noexcept {
 
            columns = std::move(other.columns);
            column_names = std::move(other.column_names);
            indices = std::move(other.indices);
            other.columns.clear();
            other.column_names.clear();
            other.indices.clear();
        }
 

        inline size_t rows() const {
 
            if (columns.empty())
                return 0;
 
            unsigned int max_rows = 0;
            for (const auto& col : columns)
                if (col.size() > max_rows)
                    max_rows = col.size();
 
            return max_rows;
        }
 

        inline size_t cols() const {
            return columns.size();
        }
 

        inline size_t size() const {
 
            size_t sum = 0;
            for (const auto& col : columns)
                sum += col.size();
 
            return sum;
        }
 

        inline bool empty() const {
            return size() == 0;
        }
 

        inline void clear() {
            columns.clear();
            column_names.clear();
            indices.clear();
        }
 

        inline std::vector<std::string> header() const {
            return column_names;
        }
 

        inline bool has_column(const std::string& name) const {
            return indices.find(name) != indices.end();
        }
 

        inline std::vector<vec<real>>& data() {
            return columns;
        }
 

        inline const std::vector<vec<real>>& data() const {
            return columns;
        }
 

        inline vec<real>& operator[](const std::string& name) {
 
            auto it = indices.find(name);
            if (it == indices.end()) {
                throw std::out_of_range("data_table::operator[]: column '" + name + "' not found");
            }
 
            return columns[it->second];
        }
 

        inline const vec<real>& operator[](const std::string& name) const {
 
            auto it = indices.find(name);
            if (it == indices.end()) {
                throw std::out_of_range("data_table::operator[]: column '" + name + "' not found");
            }
 
            return columns[it->second];
        }
 

        inline vec<real>& at(const std::string& name) {
 
            auto it = indices.find(name);
            if (it == indices.end()) {
                throw std::out_of_range("data_table::at: column '" + name + "' not found");
            }
 
            return columns[it->second];
        }
 

        inline vec<real>& operator[](size_t idx) {
            return columns[idx];
        }
 

        inline data_table select(const std::vector<std::string>& cols) const {
 
            data_table result;
 
            for (const auto& col_name : cols) {
 
                auto it = indices.find(col_name);
                if (it != indices.end()) {
                    result.column_names.emplace_back(col_name);
                    result.columns.emplace_back(columns[it->second]);
                    result.indices[col_name] = result.columns.size() - 1;
                }
            }
 
            return result;
        }
 

        inline real& at(const std::string& col, size_t row) {
 
            auto it = indices.find(col);
            if (it == indices.end()) {
                throw std::out_of_range("data_table::at: column '" + col + "' not found");
            }
 
            vec<real>& column_vec = columns[it->second];
            if (row >= column_vec.size()) {
                throw std::out_of_range("data_table::at: row index " + std::to_string(row) + " out of range");
            }
 
            return column_vec[row];
        }
 

        inline const real& at(const std::string& col, size_t row) const {
            
            auto it = indices.find(col);
            if (it == indices.end()) {
                throw std::out_of_range("data_table::at: column '" + col + "' not found");
            }
 
            const vec<real>& column_vec = columns[it->second];
            if (row >= column_vec.size()) {
                throw std::out_of_range("data_table::at: row index " + std::to_string(row) + " out of range");
            }
 
            return column_vec[row];
        }
 

        inline std::unordered_map<std::string, real> row(size_t idx) const {
 
            std::unordered_map<std::string, real> result;
 
            for (size_t i = 0; i < columns.size(); ++i) {
                const real value = idx < columns[i].size() ? columns[i][idx] : nan();
                result[column_names[i]] = value;
            }
 
            return result;
        }
 
        
        inline vec<real> row_vec(size_t idx) const {
 
            vec<real> result(columns.size());
 
            for (size_t i = 0; i < columns.size(); ++i)
                result[i] = idx < columns[i].size() ? columns[i][idx] : nan();
 
            return result;
        }
 

        inline data_table head(size_t n = 5) const {
 
            data_table result;
 
            for (size_t i = 0; i < columns.size(); ++i) {
 
                vec<real> column_head (min(n, columns[i].size()));
 
                for (size_t j = 0; j < column_head.size(); ++j)
                    column_head[j] = columns[i][j];
 
                result.column_names.emplace_back(column_names[i]);
                result.columns.emplace_back(column_head);
                result.indices[column_names[i]] = result.columns.size() - 1;
            }
 
            return result;
        }
 

        inline data_table tail(size_t n = 5) const {
            
            data_table result;
 
            for (size_t i = 0; i < columns.size(); ++i) {
 
                vec<real> column_tail(min(n, columns[i].size()));
 
                for (size_t j = 0; j < column_tail.size(); ++j)
                    column_tail[j] = columns[i][columns[i].size() - column_tail.size() + j];
 
                result.column_names.emplace_back(column_names[i]);
                result.columns.emplace_back(column_tail);
                result.indices[column_names[i]] = result.columns.size() - 1;
            }
 
            return result;
        }
 

        inline data_table& insert(const std::string& name, const vec<real>& data) {
 
            auto it = indices.find(name);
            if (it != indices.end()) {
                columns[it->second] = data;
            } else {
                column_names.emplace_back(name);
                columns.emplace_back(data);
                indices[name] = columns.size() - 1;
            }
 
            return *this;
        }
 

        inline data_table& insert(const std::string& name, size_t num_rows, real value = 0.0) {
 
            vec<real> data (num_rows, value);
            insert(name, data);
 
            return *this;
        }
 

        inline data_table& drop_column(const std::string& name) {
 
            auto it = indices.find(name);
            if (it != indices.end()) {
 
                size_t idx = it->second;
                columns.erase(columns.begin() + idx);
                column_names.erase(column_names.begin() + idx);
                indices.erase(it);
 
                // Update indices of remaining columns
                for (size_t i = idx; i < column_names.size(); ++i)
                    indices[column_names[i]] = i;
            }
 
            return *this;
        }
 

        inline data_table& drop_columns(const std::vector<std::string>& names) {
 
            for (const auto& name : names)
                drop_column(name);
 
            return *this;
        }
 

        inline data_table& rename(const std::string& old_name, const std::string& new_name) {
 
            auto it = indices.find(old_name);
            if (it != indices.end()) {
 
                size_t i = it->second;
                column_names[i] = new_name;
                indices.erase(it);
                indices[new_name] = i;
            }
 
            return *this;
        }
 

        inline mat<real> to_matrix() const {
 
            const size_t row_size = rows();
            mat<real> result (row_size, columns.size());
 
            for (size_t i = 0; i < columns.size(); ++i) {
 
                for (size_t j = 0; j < row_size; ++j)
                    result(j, i) = j < columns[i].size() ? columns[i][j] : nan();
            }
 
            return result;
        }
 

        inline data_table& from_matrix(const mat<real>& m, const std::vector<std::string>& col_names) {
 
            clear();
 
            for (size_t i = 0; i < m.cols(); ++i) {
 
                vec<real> column (m.rows());
 
                for (size_t j = 0; j < m.rows(); ++j)
                    column[j] = m(j, i);
 
                std::string col_name = i < col_names.size() ? col_names[i] : "col_" + std::to_string(i);
                column_names.emplace_back(col_name);
                columns.emplace_back(column);
                indices[col_name] = columns.size() - 1;
            }
 
            return *this;
        }
 
 
#ifndef THEORETICA_NO_PRINT

        inline std::string to_string(unsigned int max_rows = 8, unsigned int precision = 6, unsigned int max_width = 12) const {
 
            std::stringstream res;
 
            // Print column names
            for (size_t i = 0; i < column_names.size(); ++i) {
 
                if (column_names[i].size() > max_width)
                    res << std::setw(max_width + 2) << column_names[i].substr(0, max_width - 3) + "...";
                else
                    res << std::setw(max_width + 2) << column_names[i] << "\t";
            }
 
            res << "\n";
 
            // Print data rows
            size_t num_rows = columns.empty() ? 0 : columns[0].size();
            size_t rows_to_print = min(max_rows, num_rows);
 
            for (size_t i = 0; i < rows_to_print; ++i) {
 
                for (size_t j = 0; j < columns.size(); ++j) {
 
                    if (i < columns[j].size()) {
                        res << std::setw(max_width + 2) << std::setprecision(precision) << columns[j][i] << "\t";
                    } else {
                        res << std::setw(max_width + 2) << "\t";
                    }
                }
 
                res << "\n";
            }
 
            if (num_rows > max_rows) {
                res << "... " << (num_rows - max_rows) << " more rows\n";
            }
 
            return res.str();
        }
 

        inline operator std::string() {
            return to_string();
        }
 

        inline friend std::ostream& operator<<(std::ostream& out, const data_table& obj) {
            return out << obj.to_string();
        }
 
#endif
        
    };
 
}
 
 
#endif