datatable.hpp

Go to the documentation of this file.

/*************************************************************************
 *
 *  Project
 *                         _____ _____  __  __ _____
 *                        / ____|  __ \|  \/  |  __ \
 *  ___  _ __   ___ _ __ | |  __| |__) | \  / | |__) |
 * / _ \| '_ \ / _ \ '_ \| | |_ |  ___/| |\/| |  ___/
 *| (_) | |_) |  __/ | | | |__| | |    | |  | | |
 * \___/| .__/ \___|_| |_|\_____|_|    |_|  |_|_|
 *      | |
 *      |_|
 *
 * Copyright (C) Akiel Aries, <akiel@akiel.org>, et al.
 *
 * This software is licensed as described in the file LICENSE, which
 * you should have received as part of this distribution. The terms
 * among other details are referenced in the official documentation
 * seen here : https://akielaries.github.io/openGPMP/ along with
 * important files seen in this project.
 *
 * You may opt to use, copy, modify, merge, publish, distribute
 * and/or sell copies of the Software, and permit persons to whom
 * the Software is furnished to do so, under the terms of the
 * LICENSE file. As this is an Open Source effort, all implementations
 * must be of the same methodology.
 *
 *
 *
 * This software is distributed on an AS IS basis, WITHOUT
 * WARRANTY OF ANY KIND, either express or implied.
 *
 ************************************************************************/
 
/*
 * The datatable class similar to the Pandas Dataframe, R data.table, etc
 * with many more limitations.
 */
#ifndef DATATABLE_HPP
#define DATATABLE_HPP
 
#define MAX_ROWS 30
#define SHOW_ROWS 15
 
#include <algorithm>
#include <chrono>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
namespace gpmp {
 
namespace core {
 
enum class DataType { Unknown, String, Integer, Double };
 
typedef std::pair<std::vector<std::string>,
                  std::vector<std::vector<std::string>>>
    DataTableStr;
typedef std::pair<std::vector<int64_t>, std::vector<std::vector<int64_t>>>
    DataTableInt;
typedef std::pair<std::vector<long double>,
                  std::vector<std::vector<long double>>>
    DataTableDouble;
 
class DataTable {
  private:
    // original DataTable object headers
    std::vector<std::string> headers_;
    // original DataTable object rows
    std::vector<std::vector<std::string>> rows_;
    // modified DataTable object headers
    std::vector<std::string> new_headers_;
    // vector to hold data
    std::vector<std::vector<std::string>> data_;
 
    // original DataTable data
    DataTableStr original_data_;
 
  public:
    DataTable() {
        // Initialize data_ and headers_ to empty vectors
        data_ = std::vector<std::vector<std::string>>();
        headers_ = std::vector<std::string>();
    }
 
    DataTableStr csv_read(std::string filename,
                          std::vector<std::string> columns = {});
 
    void csv_write();
 
    // TODO: TOML and JSON readers?
    DataTableStr tsv_read(std::string filename,
                          std::vector<std::string> columns = {});
 
    DataTableStr json_read(std::string filename,
                           std::vector<std::string> objs = {});
 
    DataTableStr datetime(std::string column_name,
                          bool extract_year = true,
                          bool extract_month = true,
                          bool extract_time = false);
 
    void sort(const std::vector<std::string> &sort_columns,
              bool ascending = true);
 
    // customSort(const std::vector<std::string>& columnNames,
    // gpmp::core::DataTableStr& data);
 
    std::vector<DataTableStr>
    group_by(std::vector<std::string> group_by_columns);
 
    DataTableStr
    first(const std::vector<gpmp::core::DataTableStr> &groups) const;
 
    void describe();
 
    DataTableInt str_to_int(DataTableStr src);
 
    DataTableDouble str_to_double(DataTableStr src);
 
    template <typename T>
    void display(std::pair<std::vector<T>, std::vector<std::vector<T>>> data,
                 bool display_all = false) {
        // Get the number of columns and rows in the data
        int num_columns = data.first.size();
        int num_rows = data.second.size();
        int num_omitted_rows = 0;
 
        // Initialize max_column_widths with the lengths of column headers
        std::vector<int> max_column_widths(num_columns, 0);
 
        // Calculate the maximum width for each column based on column headers
        for (int i = 0; i < num_columns; i++) {
            max_column_widths[i] = data.first[i].length();
        }
 
        // Calculate the maximum width for each column based on data rows
        for (int i = 0; i < num_columns; i++) {
            for (const auto &row : data.second) {
                if (i < static_cast<int>(row.size())) {
                    max_column_widths[i] =
                        std::max(max_column_widths[i],
                                 static_cast<int>(row[i].length()));
                }
            }
        }
 
        // Set a larger width for the DateTime column (adjust the index as
        // needed later on)
        const int dateTimeColumnIndex = 0;
        // adjust as needed?
        max_column_widths[dateTimeColumnIndex] =
            std::max(max_column_widths[dateTimeColumnIndex], 0);
 
        // Print headers with right-aligned values
        std::cout << std::setw(7) << std::right << "Index"
                  << "  ";
 
        for (int i = 0; i < num_columns; i++) {
            std::cout << std::setw(max_column_widths[i]) << std::right
                      << data.first[i] << "  ";
        }
        std::cout << std::endl;
 
        int num_elements = data.second.size();
        if (!display_all && num_elements > MAX_ROWS) {
            for (int i = 0; i < SHOW_ROWS; i++) {
                // Prit index
                std::cout << std::setw(7) << std::right << i << "  ";
                // Print each row with right-aligned values
                for (int j = 0; j < num_columns; j++) {
                    if (j < static_cast<int>(data.second[i].size())) {
                        std::cout << std::setw(max_column_widths[j])
                                  << std::right << data.second[i][j] << "  ";
                    }
                }
                std::cout << std::endl;
            }
            num_omitted_rows = num_elements - MAX_ROWS;
            std::cout << "...\n";
            std::cout << "[" << num_omitted_rows << " rows omitted]\n";
            for (int i = num_elements - SHOW_ROWS; i < num_elements; i++) {
                std::cout << std::setw(7) << std::right << i << "  ";
                // Print each row with right-aligned values
                for (int j = 0; j < num_columns; j++) {
                    if (j < static_cast<int>(data.second[i].size())) {
                        std::cout << std::setw(max_column_widths[j])
                                  << std::right << data.second[i][j] << "  ";
                    }
                }
                std::cout << std::endl;
            }
        } else {
            // Print all rows with right-aligned values
            for (int i = 0; i < num_elements; i++) {
 
                // Print index
                std::cout << std::setw(7) << std::right << i << "  ";
                for (int j = 0; j < num_columns; j++) {
                    if (j < static_cast<int>(data.second[i].size())) {
 
                        // Print formatted row
                        std::cout << std::setw(max_column_widths[j])
                                  << std::right << data.second[i][j] << "  ";
                    }
                }
                std::cout << std::endl;
            }
        }
 
        // Print the number of rows and columns
        std::cout << "[" << num_rows << " rows"
                  << " x " << num_columns << " columns";
        std::cout << "]\n\n";
    }
 
    void display(bool display_all = false) {
        display(std::make_pair(headers_, data_), display_all);
    }
};
 
} // namespace core
} // namespace gpmp
 
#endif // DATATABLE_HPP