parent
f3762595a8
commit
3051eb5fe7
@ -1,61 +1,79 @@
|
||||
#include "./server/hasher.h"
|
||||
#include "./server/aggregations.h"
|
||||
#include "csv.h"
|
||||
#include "./server/libaquery.h"
|
||||
#include <unordered_map>
|
||||
#include "./server/aggregations.h"
|
||||
|
||||
extern "C" int __DLLEXPORT__ dllmain(Context* cxt) {
|
||||
using namespace std;
|
||||
using namespace types;
|
||||
|
||||
auto sale = new TableInfo<int,int>("sale", 2);
|
||||
cxt->tables.insert({"sale", sale});
|
||||
auto& sale_Month = *(ColRef<int> *)(&sale->colrefs[0]);
|
||||
auto& sale_sales = *(ColRef<int> *)(&sale->colrefs[1]);
|
||||
sale_Month.init();
|
||||
sale_sales.init();
|
||||
io::CSVReader<2> csv_reader_6T89Ll("moving_avg.csv");
|
||||
csv_reader_6T89Ll.read_header(io::ignore_extra_column, "Month","sales");
|
||||
int tmp_5vttJ2yV;
|
||||
int tmp_2ckq15YU;
|
||||
while(csv_reader_6T89Ll.read_row(tmp_5vttJ2yV,tmp_2ckq15YU)) {
|
||||
|
||||
sale_Month.emplace_back(tmp_5vttJ2yV);
|
||||
sale_sales.emplace_back(tmp_2ckq15YU);
|
||||
}
|
||||
auto out_2UiD = new TableInfo<value_type<decays<decltype(sale_Month)>>,value_type<decays<decltype(avgw(3,sale_sales))>>>("out_2UiD", 2);
|
||||
cxt->tables.insert({"out_2UiD", out_2UiD});
|
||||
auto& out_2UiD_Month = *(ColRef<value_type<decays<decltype(sale_Month)>>> *)(&out_2UiD->colrefs[0]);
|
||||
auto& out_2UiD_avgw3salesales = *(ColRef<value_type<decays<decltype(avgw(3,sale_sales))>>> *)(&out_2UiD->colrefs[1]);
|
||||
auto order_1NNZ9F = sale->order_by<0>();
|
||||
out_2UiD_Month.init();
|
||||
out_2UiD_Month = sale_Month[*order_1NNZ9F];
|
||||
out_2UiD_avgw3salesales.init();
|
||||
out_2UiD_avgw3salesales = avgw(3,sale_sales[*order_1NNZ9F]);
|
||||
print(*out_2UiD);
|
||||
FILE* fp_6xIJn4 = fopen("moving_avg_output.csv", "w");
|
||||
out_2UiD->printall(";", "\n", nullptr, fp_6xIJn4);
|
||||
fclose(fp_6xIJn4);
|
||||
typedef record<decltype(sale_sales[0])> record_type6Lepq5T;
|
||||
unordered_map<record_type6Lepq5T, vector_type<uint32_t>, transTypes<record_type6Lepq5T, hasher>> g4loWjmn;
|
||||
for (uint32_t i5g = 0; i5g < sale_sales.size; ++i5g){
|
||||
g4loWjmn[forward_as_tuple(sale_sales[i5g])].emplace_back(i5g);
|
||||
}
|
||||
auto out_2YlO = new TableInfo<value_type<decays<decltype(sale_sales)>>,decays<decltype(minw(2,sale_Month))>>("out_2YlO", 2);
|
||||
cxt->tables.insert({"out_2YlO", out_2YlO});
|
||||
auto& out_2YlO_sales = *(ColRef<value_type<decays<decltype(sale_sales)>>> *)(&out_2YlO->colrefs[0]);
|
||||
auto& out_2YlO_minw2saleMonth = *(ColRef<decays<decltype(minw(2,sale_Month))>> *)(&out_2YlO->colrefs[1]);
|
||||
out_2YlO_sales.init();
|
||||
out_2YlO_minw2saleMonth.init();
|
||||
for(auto& iFU : g4loWjmn) {
|
||||
auto &key_3AwvKMR = iFU.first;
|
||||
auto &val_7jtE12E = iFU.second;
|
||||
out_2YlO_sales.emplace_back(get<0>(key_3AwvKMR));
|
||||
out_2YlO_minw2saleMonth.emplace_back(minw(2,sale_Month[val_7jtE12E]));
|
||||
}
|
||||
print(*out_2YlO);
|
||||
FILE* fp_45ld6S = fopen("flatten.csv", "w");
|
||||
out_2YlO->printall(",", "\n", nullptr, fp_45ld6S);
|
||||
fclose(fp_45ld6S);
|
||||
auto stocks = new TableInfo<int,int>("stocks", 2);
|
||||
cxt->tables.insert({"stocks", stocks});
|
||||
auto& stocks_timestamp = *(ColRef<int> *)(&stocks->colrefs[0]);
|
||||
auto& stocks_price = *(ColRef<int> *)(&stocks->colrefs[1]);
|
||||
stocks_timestamp.init();
|
||||
stocks_price.init();
|
||||
stocks_timestamp.emplace_back(1);
|
||||
stocks_price.emplace_back(15);
|
||||
stocks_timestamp.emplace_back(2);
|
||||
stocks_price.emplace_back(19);
|
||||
stocks_timestamp.emplace_back(3);
|
||||
stocks_price.emplace_back(16);
|
||||
stocks_timestamp.emplace_back(4);
|
||||
stocks_price.emplace_back(17);
|
||||
stocks_timestamp.emplace_back(5);
|
||||
stocks_price.emplace_back(15);
|
||||
stocks_timestamp.emplace_back(6);
|
||||
stocks_price.emplace_back(13);
|
||||
stocks_timestamp.emplace_back(7);
|
||||
stocks_price.emplace_back(5);
|
||||
stocks_timestamp.emplace_back(8);
|
||||
stocks_price.emplace_back(8);
|
||||
stocks_timestamp.emplace_back(9);
|
||||
stocks_price.emplace_back(7);
|
||||
stocks_timestamp.emplace_back(10);
|
||||
stocks_price.emplace_back(13);
|
||||
stocks_timestamp.emplace_back(11);
|
||||
stocks_price.emplace_back(11);
|
||||
stocks_timestamp.emplace_back(12);
|
||||
stocks_price.emplace_back(14);
|
||||
stocks_timestamp.emplace_back(13);
|
||||
stocks_price.emplace_back(10);
|
||||
stocks_timestamp.emplace_back(14);
|
||||
stocks_price.emplace_back(5);
|
||||
stocks_timestamp.emplace_back(15);
|
||||
stocks_price.emplace_back(2);
|
||||
stocks_timestamp.emplace_back(16);
|
||||
stocks_price.emplace_back(5);
|
||||
auto out_oMxe = new TableInfo<value_type<decays<decltype(max((stocks_price-min(stocks_timestamp))))>>>("out_oMxe", 1);
|
||||
cxt->tables.insert({"out_oMxe", out_oMxe});
|
||||
auto& out_oMxe_maxstockspriceminstockstimestamp = *(ColRef<value_type<decays<decltype(max((stocks_price-min(stocks_timestamp))))>>> *)(&out_oMxe->colrefs[0]);
|
||||
out_oMxe_maxstockspriceminstockstimestamp.init();
|
||||
out_oMxe_maxstockspriceminstockstimestamp = max((stocks_price-min(stocks_timestamp)));
|
||||
print(*out_oMxe);
|
||||
auto out_2ZWg = new TableInfo<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>>("out_2ZWg", 1);
|
||||
cxt->tables.insert({"out_2ZWg", out_2ZWg});
|
||||
auto& out_2ZWg_maxstockspriceminsstocksprice = *(ColRef<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>> *)(&out_2ZWg->colrefs[0]);
|
||||
out_2ZWg_maxstockspriceminsstocksprice.init();
|
||||
out_2ZWg_maxstockspriceminsstocksprice = max((stocks_price-mins(stocks_price)));
|
||||
print(*out_2ZWg);
|
||||
const auto& tmp_sz_B19sAY = stocks_timestamp.size;
|
||||
auto out_JZsz = new TableInfo<value_type<decays<decltype(stocks_price)>>,value_type<decays<decltype(stocks_timestamp)>>>("out_JZsz", 2);
|
||||
cxt->tables.insert({"out_JZsz", out_JZsz});
|
||||
auto& out_JZsz_price = *(ColRef<value_type<decays<decltype(stocks_price)>>> *)(&out_JZsz->colrefs[0]);
|
||||
auto& out_JZsz_timestamp = *(ColRef<value_type<decays<decltype(stocks_timestamp)>>> *)(&out_JZsz->colrefs[1]);
|
||||
out_JZsz_price.init();
|
||||
out_JZsz_timestamp.init();
|
||||
for (uint32_t i3D = 0; i3D < tmp_sz_B19sAY; ++i3D){
|
||||
if ((((stocks_price[i3D]-stocks_timestamp[i3D])>=1)&&!(((stocks_price[i3D]*stocks_timestamp[i3D])<100)))) {
|
||||
out_JZsz_price = stocks_price[i3D];
|
||||
out_JZsz_timestamp = stocks_timestamp[i3D];
|
||||
}}
|
||||
print(*out_JZsz);
|
||||
auto out_2Fm0 = new TableInfo<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>>("out_2Fm0", 1);
|
||||
cxt->tables.insert({"out_2Fm0", out_2Fm0});
|
||||
auto& out_2Fm0_maxstockspriceminsstocksprice = *(ColRef<value_type<decays<decltype(max((stocks_price-mins(stocks_price))))>>> *)(&out_2Fm0->colrefs[0]);
|
||||
auto order_5qqTLa = stocks->order_by<-1>();
|
||||
out_2Fm0_maxstockspriceminsstocksprice.init();
|
||||
out_2Fm0_maxstockspriceminsstocksprice = max((stocks_price[*order_5qqTLa]-mins(stocks_price[*order_5qqTLa])));
|
||||
print(*out_2Fm0);
|
||||
return 0;
|
||||
}
|
||||
@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
#include "types.h"
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
template <class ...Types>
|
||||
std::string generate_printf_string(const char* sep = " ", const char* end = "\n") {
|
||||
std::string str;
|
||||
((str += types::printf_str[types::Types<value_type_r<Types>>::getType()], str += sep), ...);
|
||||
const auto trim = str.size() - strlen(sep);
|
||||
if (trim > 0)
|
||||
str.resize(trim);
|
||||
str += end;
|
||||
return str;
|
||||
}
|
||||
|
||||
@ -0,0 +1,443 @@
|
||||
// TODO: Replace `cout, printf` with sprintf&fputs and custom buffers
|
||||
|
||||
#ifndef _TABLE_H
|
||||
#define _TABLE_H
|
||||
|
||||
#include "types.h"
|
||||
#include "vector_type.hpp"
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include "io.h"
|
||||
template <typename T>
|
||||
class vector_type;
|
||||
template <>
|
||||
class vector_type<void>;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
namespace types {
|
||||
enum Type_t;
|
||||
template <typename T>
|
||||
struct Types;
|
||||
template <class T1, class T2>
|
||||
struct Coercion;
|
||||
}
|
||||
#endif
|
||||
template<typename _Ty>
|
||||
class ColView;
|
||||
template<typename _Ty>
|
||||
class ColRef : public vector_type<_Ty>
|
||||
{
|
||||
public:
|
||||
typedef ColRef<_Ty> Decayed_t;
|
||||
const char* name;
|
||||
types::Type_t ty = types::ERROR;
|
||||
ColRef() : vector_type<_Ty>(0), name("") {}
|
||||
ColRef(const uint32_t& size, const char* name = "") : vector_type<_Ty>(size), name(name) {}
|
||||
ColRef(const char* name) : name(name) {}
|
||||
void init(const char* name = "") { ty = types::Types<_Ty>::getType(); this->size = this->capacity = 0; this->container = 0; this->name = name; }
|
||||
ColRef(const char* name, types::Type_t ty) : name(name), ty(ty) {}
|
||||
using vector_type<_Ty>::operator[];
|
||||
using vector_type<_Ty>::operator=;
|
||||
ColView<_Ty> operator [](const vector_type<uint32_t>&idxs) const {
|
||||
return ColView<_Ty>(*this, idxs);
|
||||
}
|
||||
|
||||
void out(uint32_t n = 4, const char* sep = " ") const {
|
||||
n = n > this->size ? this->size : n;
|
||||
std::cout << '(';
|
||||
for (uint32_t i = 0; i < n; ++i)
|
||||
std::cout << this->operator[](i) << sep;
|
||||
std::cout << ')';
|
||||
}
|
||||
template<typename T>
|
||||
ColRef<T> scast();
|
||||
};
|
||||
|
||||
template<typename _Ty>
|
||||
class ColView {
|
||||
public:
|
||||
typedef ColRef<_Ty> Decayed_t;
|
||||
const vector_type<uint32_t>& idxs;
|
||||
const ColRef<_Ty>& orig;
|
||||
const uint32_t& size;
|
||||
ColView(const ColRef<_Ty>& orig, const vector_type<uint32_t>& idxs) : orig(orig), idxs(idxs), size(idxs.size) {}
|
||||
ColView(const ColView<_Ty>& orig, const vector_type<uint32_t>& idxs) : orig(orig.orig), idxs(idxs), size(idxs.size) {
|
||||
for (uint32_t i = 0; i < size; ++i)
|
||||
idxs[i] = orig.idxs[idxs[i]];
|
||||
}
|
||||
_Ty& operator [](const uint32_t& i) const {
|
||||
return orig[idxs[i]];
|
||||
}
|
||||
struct Iterator_t {
|
||||
const uint32_t* val;
|
||||
const ColRef<_Ty>& orig;
|
||||
constexpr Iterator_t(const uint32_t* val, const ColRef<_Ty>& orig) noexcept : val(val), orig(orig) {}
|
||||
_Ty& operator*() { return orig[*val]; }
|
||||
bool operator != (const Iterator_t& rhs) { return rhs.val != val; }
|
||||
Iterator_t& operator++ () {
|
||||
++val;
|
||||
return *this;
|
||||
}
|
||||
Iterator_t operator++ (int) {
|
||||
Iterator_t tmp = *this;
|
||||
++val;
|
||||
return tmp;
|
||||
}
|
||||
};
|
||||
Iterator_t begin() const {
|
||||
return Iterator_t(idxs.begin(), orig);
|
||||
}
|
||||
Iterator_t end() const {
|
||||
return Iterator_t(idxs.end(), orig);
|
||||
}
|
||||
void out(uint32_t n = 4, const char* sep = " ") const {
|
||||
n = n > size ? size : n;
|
||||
std::cout<<'(';
|
||||
for (uint32_t i = 0; i < n; ++i)
|
||||
std::cout << this->operator[](i)<< sep;
|
||||
std::cout << ')';
|
||||
}
|
||||
operator ColRef<_Ty>() {
|
||||
auto ret = ColRef<_Ty>(size);
|
||||
for (uint32_t i = 0; i < size; ++i)
|
||||
ret[i] = orig[idxs[i]];
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
template <template <class...> class VT, class T>
|
||||
std::ostream& operator<<(std::ostream& os, const VT<T>& v)
|
||||
{
|
||||
v.out();
|
||||
return os;
|
||||
}
|
||||
template <class Type>
|
||||
struct decayed_impl<ColView, Type> { typedef ColRef<Type> type; };
|
||||
template<typename _Ty>
|
||||
template<typename T>
|
||||
inline ColRef<T> ColRef<_Ty>::scast()
|
||||
{
|
||||
this->ty = types::Types<T>::getType();
|
||||
return *(ColRef<T> *)this;
|
||||
}
|
||||
using uColRef = ColRef<void>;
|
||||
|
||||
template<class ...Types> struct TableInfo;
|
||||
template<class ...Types> struct TableView;
|
||||
|
||||
template <long long _Index, bool order = true, class... _Types>
|
||||
constexpr inline auto& get(const TableInfo<_Types...>& table) noexcept {
|
||||
if constexpr (order)
|
||||
return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.colrefs[_Index]);
|
||||
else
|
||||
return *(ColRef<std::tuple_element_t<-1-_Index, std::tuple<_Types...>>> *) & (table.colrefs[-1-_Index]);
|
||||
}
|
||||
|
||||
template <long long _Index, class... _Types>
|
||||
constexpr inline ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>>& get(const TableView<_Types...>& table) noexcept {
|
||||
return *(ColRef<std::tuple_element_t<_Index, std::tuple<_Types...>>> *) & (table.info.colrefs[_Index]);
|
||||
}
|
||||
|
||||
template <class V>
|
||||
struct is_vector_impl<ColRef<V>> : std::true_type {};
|
||||
template <class V>
|
||||
struct is_vector_impl<ColView<V>> : std::true_type {};
|
||||
template <class V>
|
||||
struct is_vector_impl<vector_type<V>> : std::true_type {};
|
||||
|
||||
template<class ...Types>
|
||||
struct TableView;
|
||||
template<class ...Types>
|
||||
struct TableInfo {
|
||||
const char* name;
|
||||
ColRef<void>* colrefs;
|
||||
uint32_t n_cols;
|
||||
typedef std::tuple<Types...> tuple_type;
|
||||
void print(const char* __restrict sep, const char* __restrict end) const;
|
||||
|
||||
template <class ...Types2>
|
||||
struct lineage_t {
|
||||
TableInfo<Types...>* this_table;
|
||||
TableInfo<Types2...>* table;
|
||||
vector_type<uint32_t> rid;
|
||||
constexpr lineage_t(TableInfo<Types...>*this_table, TableInfo<Types2...> *table)
|
||||
: this_table(this_table), table(table), rid(0) {}
|
||||
constexpr lineage_t() : this_table(0), table(0), rid(0) {}
|
||||
|
||||
template <int col>
|
||||
inline auto& get(uint32_t idx) {
|
||||
return get<col>(*table)[rid[idx]];
|
||||
}
|
||||
void emplace_back(const uint32_t& v) {
|
||||
rid.emplace_back(v);
|
||||
}
|
||||
};
|
||||
template<class ...Types2>
|
||||
auto bind(TableInfo<Types2...>* table2) {
|
||||
return lineage_t(this, table2);
|
||||
}
|
||||
|
||||
template <size_t j = 0>
|
||||
typename std::enable_if<j == sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
|
||||
template <size_t j = 0>
|
||||
typename std::enable_if<j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
|
||||
template <size_t ...Idxs>
|
||||
struct GetTypes {
|
||||
typedef typename std::tuple<typename std::tuple_element<Idxs, tuple_type>::type ...> type;
|
||||
};
|
||||
template <size_t ...Idxs>
|
||||
using getRecordType = typename GetTypes<Idxs...>::type;
|
||||
TableInfo(const char* name, uint32_t n_cols);
|
||||
template <int prog = 0>
|
||||
inline void materialize(const vector_type<uint32_t>& idxs, TableInfo<Types...>* tbl = nullptr) { // inplace materialize
|
||||
if constexpr(prog == 0) tbl = (tbl == 0 ? this : tbl);
|
||||
if constexpr (prog == sizeof...(Types)) return;
|
||||
else {
|
||||
auto& col = get<prog>(*this);
|
||||
auto new_col = decays<decltype(col)>{idxs.size};
|
||||
for(uint32_t i = 0; i < idxs.size; ++i)
|
||||
new_col[i] = col[idxs[i]];
|
||||
get<prog>(*tbl) = new_col;
|
||||
materialize<prog + 1>(idxs, tbl);
|
||||
}
|
||||
}
|
||||
inline TableInfo<Types...>* materialize_copy(const vector_type<uint32_t>& idxs) {
|
||||
auto tbl = new TableInfo<Types...>(this->name, sizeof...(Types));
|
||||
materialize<0>(idxs, tbl);
|
||||
return tbl;
|
||||
}
|
||||
template<int ...cols>
|
||||
inline vector_type<uint32_t>* order_by(vector_type<uint32_t>* ord = nullptr) {
|
||||
if (!ord) {
|
||||
ord = new vector_type<uint32_t>(colrefs[0].size);
|
||||
for (uint32_t i = 0; i < colrefs[0].size; ++i)
|
||||
(*ord)[i] = i;
|
||||
}
|
||||
std::sort(ord->begin(), ord->end(), [this](const uint32_t& lhs, const uint32_t& rhs) {
|
||||
return
|
||||
std::forward_as_tuple((cols >= 0 ? get<cols, (cols >= 0)>(*this)[lhs] : -get<cols, (cols >= 0)>(*this)[lhs]) ...)
|
||||
<
|
||||
std::forward_as_tuple((cols >= 0 ? get<cols, (cols >= 0)>(*this)[rhs] : -get<cols, (cols >= 0)>(*this)[rhs]) ...);
|
||||
});
|
||||
return ord;
|
||||
}
|
||||
template <int ...cols>
|
||||
auto order_by_view () {
|
||||
return TableView<Types...>(order_by<cols...>(), *this);
|
||||
}
|
||||
|
||||
// Print 2 -- generate printf string first, supports flattening, supports sprintf/printf/fprintf
|
||||
template <int col, int ...rem_cols, class Fn, class ...__Types>
|
||||
inline void print2_impl(Fn func, const uint32_t& i, const __Types& ... args) const {
|
||||
using this_type = typename std::tuple_element<col, tuple_type>::type;
|
||||
const auto& this_value = get<col>(*this)[i];
|
||||
const auto& next = [&](auto &v) {
|
||||
if constexpr (sizeof...(rem_cols) == 0)
|
||||
func(args..., v);
|
||||
else
|
||||
print2_impl<rem_cols...>(func, i, args ..., v);
|
||||
};
|
||||
if constexpr (is_vector_type<this_type>)
|
||||
for (int j = 0; j < this_value.size; ++j)
|
||||
next(this_value[j]);
|
||||
else
|
||||
next(this_value);
|
||||
}
|
||||
template <int ...cols>
|
||||
void print2(const char* __restrict sep = ",", const char* __restrict end = "\n",
|
||||
const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) const {
|
||||
std::string printf_string =
|
||||
generate_printf_string<typename std::tuple_element<cols, tuple_type>::type ...>(sep, end);
|
||||
const auto& prt_loop = [&fp, &view, &printf_string, *this](const auto& f) {
|
||||
if(view)
|
||||
for (int i = 0; i < view->size; ++i)
|
||||
print2_impl<cols...>(f, (*view)[i], printf_string.c_str());
|
||||
else
|
||||
for (int i = 0; i < colrefs[0].size; ++i)
|
||||
print2_impl<cols...>(f, i, printf_string.c_str());
|
||||
};
|
||||
if (fp)
|
||||
prt_loop([&fp](auto... args) { fprintf(fp, args...); });
|
||||
else
|
||||
prt_loop(printf);
|
||||
}
|
||||
template <int ...vals> struct applier {
|
||||
inline constexpr static void apply(const TableInfo<Types...>& t, const char* __restrict sep = ",", const char* __restrict end = "\n",
|
||||
const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr)
|
||||
{ t.template print2<vals ...>(sep, end, view, fp); }};
|
||||
|
||||
inline void printall(const char* __restrict sep = ",", const char* __restrict end = "\n",
|
||||
const vector_type<uint32_t>* __restrict view = nullptr, FILE* __restrict fp = nullptr) {
|
||||
applyIntegerSequence<sizeof...(Types), applier>::apply(*this, sep, end, view, fp);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template<class ...Types>
|
||||
struct TableView {
|
||||
const vector_type<uint32_t>* idxs;
|
||||
const TableInfo<Types...>& info;
|
||||
constexpr TableView(const vector_type<uint32_t>* idxs, const TableInfo<Types...>& info) noexcept : idxs(idxs), info(info) {}
|
||||
void print(const char* __restrict sep, const char* __restrict end) const;
|
||||
template <size_t j = 0>
|
||||
typename std::enable_if<j == sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
|
||||
template <size_t j = 0>
|
||||
typename std::enable_if < j < sizeof...(Types) - 1, void>::type print_impl(const uint32_t& i, const char* __restrict sep = " ") const;
|
||||
|
||||
~TableView() {
|
||||
delete idxs;
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
constexpr static inline bool is_vector(const ColRef<T>&) {
|
||||
return true;
|
||||
}
|
||||
template <class T>
|
||||
constexpr static inline bool is_vector(const vector_type<T>&) {
|
||||
return true;
|
||||
}
|
||||
|
||||
template<class ...Types>
|
||||
TableInfo<Types...>::TableInfo(const char* name, uint32_t n_cols) : name(name), n_cols(n_cols) {
|
||||
this->colrefs = (ColRef<void>*)malloc(sizeof(ColRef<void>) * n_cols);
|
||||
}
|
||||
template <class ...Types>
|
||||
template <size_t j>
|
||||
inline typename std::enable_if<j == sizeof...(Types) - 1, void>::type
|
||||
TableView<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
|
||||
std::cout << (get<j>(*this))[(*idxs)[i]];
|
||||
}
|
||||
|
||||
template<class ...Types>
|
||||
template<size_t j>
|
||||
inline typename std::enable_if < j < sizeof...(Types) - 1, void>::type
|
||||
TableView<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
|
||||
{
|
||||
std::cout << (get<j>(*this))[(*idxs)[i]] << sep;
|
||||
print_impl<j + 1>(i, sep);
|
||||
}
|
||||
|
||||
template<class ...Types>
|
||||
inline void TableView<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
|
||||
int n_rows = 0;
|
||||
if (info.colrefs[0].size > 0)
|
||||
n_rows = info.colrefs[0].size;
|
||||
for (int i = 0; i < n_rows; ++i) {
|
||||
print_impl(i);
|
||||
std::cout << end;
|
||||
}
|
||||
}
|
||||
template <class ...Types>
|
||||
template <size_t j>
|
||||
inline typename std::enable_if<j == sizeof...(Types) - 1, void>::type
|
||||
TableInfo<Types ...>::print_impl(const uint32_t& i, const char* __restrict sep) const {
|
||||
std::cout << (get<j>(*this))[i];
|
||||
}
|
||||
|
||||
template<class ...Types>
|
||||
template<size_t j>
|
||||
inline typename std::enable_if<j < sizeof...(Types) - 1, void>::type
|
||||
TableInfo<Types...>::print_impl(const uint32_t& i, const char* __restrict sep) const
|
||||
{
|
||||
std::cout << (get<j>(*this))[i] << sep;
|
||||
print_impl<j+1>(i, sep);
|
||||
}
|
||||
|
||||
template<class ...Types>
|
||||
inline void TableInfo<Types...>::print(const char* __restrict sep, const char* __restrict end) const {
|
||||
int n_rows = 0;
|
||||
if (n_cols > 0 && colrefs[0].size > 0)
|
||||
n_rows = colrefs[0].size;
|
||||
for (int i = 0; i < n_rows; ++i) {
|
||||
print_impl(i);
|
||||
std::cout << end;
|
||||
}
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator -(const VT<T1>& lhs, const VT2<T2>& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] - rhs[i];
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator -(const VT<T1>& lhs, const T2& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] - rhs;
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator +(const VT<T1>& lhs, const VT2<T2>& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] + rhs[i];
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator +(const VT<T1>& lhs, const T2& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] + rhs;
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator *(const VT<T1>& lhs, const VT2<T2>& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] * rhs[i];
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator *(const VT<T1>& lhs, const T2& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] * rhs;
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT, template<typename ...> class VT2>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator /(const VT<T1>& lhs, const VT2<T2>& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] / rhs[i];
|
||||
return ret;
|
||||
}
|
||||
template <class T1, class T2, template<typename ...> class VT>
|
||||
decayed_t<VT, typename types::Coercion<T1, T2>::type> operator /(const VT<T1>& lhs, const T2& rhs) {
|
||||
auto ret = decayed_t<VT, typename types::Coercion<T1, T2>::type>(lhs.size, "");
|
||||
for (int i = 0; i < lhs.size; ++i)
|
||||
ret[i] = lhs[i] / rhs;
|
||||
return ret;
|
||||
}
|
||||
|
||||
template <class ...Types>
|
||||
void print(const TableInfo<Types...>& v, const char* delimiter = " ", const char* endline = "\n") {
|
||||
v.print(delimiter, endline);
|
||||
}
|
||||
template <class ...Types>
|
||||
void print(const TableView<Types...>& v, const char* delimiter = " ", const char* endline = "\n") {
|
||||
v.print(delimiter, endline);
|
||||
}
|
||||
template <class T>
|
||||
void print(const T& v, const char* delimiter = " ") {
|
||||
std::cout<< v;
|
||||
// printf(types::printf_str[types::Types<T>::getType()], v);
|
||||
}
|
||||
template <class T>
|
||||
void inline print_impl(const T& v, const char* delimiter, const char* endline) {
|
||||
for (const auto& vi : v) {
|
||||
print(vi);
|
||||
std::cout << delimiter;
|
||||
// printf("%s", delimiter);
|
||||
}
|
||||
std::cout << endline;
|
||||
//printf("%s", endline);
|
||||
}
|
||||
|
||||
template <class T, template<typename> class VT>
|
||||
typename std::enable_if<!std::is_same<VT<T>, TableInfo<T>>::value>::type
|
||||
print(const VT<T>& v, const char* delimiter = " ", const char* endline = "\n") {
|
||||
print_impl(v, delimiter, endline);
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Reference in new issue