datatable_wip.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 <iostream>
#include <string>
#include <variant>
#include <vector>
 
namespace gpmp {
 
namespace core {
 
enum class DataType {
    dt_uint8,   
    dt_int8,    
    dt_uint16,  
    dt_int16,   
    dt_uint32,  
    dt_int32,   
    dt_uint64,  
    dt_int64,   
    dt_double,  
    dt_ldouble, 
    dt_str,     
};
 
typedef std::pair<
    std::vector<std::string>,
    std::vector<std::vector<std::variant<int64_t, long double, std::string>>>>
    TableType;
 
typedef std::vector<
    std::vector<std::variant<int64_t, long double, std::string>>>
    MixedType;
 
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
    MixedType rows_;
    // modified DataTable object headers
    std::vector<std::string> new_headers_;
    // vector to hold data
    MixedType data_;
 
    // original DataTable data
    DataTableStr original_data_;
 
  public:
    DataTable() {
        // Initialize data_ and headers_ to empty vectors
        headers_ = std::vector<std::string>();
        data_ = MixedType();
    }
    void printData() {
        // Print column headers
        for (const auto &header : headers_) {
            std::cout << header << "\t";
        }
        std::cout << std::endl;
 
        // Print data rows
        for (const auto &row : data_) {
            for (const auto &cell : row) {
                // Check the type of cell and print accordingly
                if (std::holds_alternative<int64_t>(cell)) {
                    std::cout << std::get<int64_t>(cell);
                } else if (std::holds_alternative<long double>(cell)) {
                    std::cout << std::get<long double>(cell);
                } else if (std::holds_alternative<std::string>(cell)) {
                    std::cout << std::get<std::string>(cell);
                }
 
                std::cout << "\t";
            }
            std::cout << std::endl;
        }
    }
 
    // DataTableStr csv_read(std::string filename,
    //                       std::vector<std::string> columns = {});
 
    TableType csv_read_new(std::string filename,
                           std::vector<std::string> columns = {});
 
    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 = {});
 
    void drop(std::vector<std::string> column_name);
 
    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();
 
    void info();
 
    TableType native_type(const std::vector<std::string> &skip_columns = {});
 
    DataType inferType(const std::vector<std::string> &column);
 
    DataTableInt str_to_int(DataTableStr src);
 
    DataTableDouble str_to_double(DataTableStr src);
 
    // TODO : edit this display method to read in the first 15 and last 15 by
    // default. if display_all = true then fetch all rows
    void display(const TableType &data, bool display_all = false);
 
    void display(bool display_all = false);
};
 
} // namespace core
} // namespace gpmp
 
#endif // DATATABLE_HPP