xdata.h

Go to the documentation of this file.

#pragma once

#include "xview.h"
#include "xerror.h"
#include "xoutput.h"
#include <array>
#include <cmath>
#include <fstream>
#include <functional>
#include <optional>
#include <vector>

namespace nmx {

template<size_t N>
class Data
{
public:
    using Row = std::array<double, N>;
    using Container = std::vector<Row>;
    using Column = std::vector<double>;
    using View = View<Data<N>>;

private:
    Container _data;

public:
    inline Data() {}

    inline const auto &data() const { return _data; }

    inline auto &data() { return _data; }

    inline Row &first() { return *_data.begin(); }

    inline const Row &first() const { return *_data.begin(); }

    inline Row &last() { return *(_data.end() - 1); }

    inline const Row &last() const { return *(_data.end() - 1); }

    inline const auto &row(size_t idx) const {
        //wenn ungültiger Index: out_of_range Ausnahme
        return _data.at(idx);
    }

    inline auto &row(size_t idx) {
        //wenn ungültiger Index: out_of_range Ausnahme
        return _data.at(idx);
    }

    inline size_t rows() const { return _data.size(); }

    inline size_t columns() const { return N; }

    inline void add(const Row &lst) { _data.push_back(lst); }

    inline void add(std::initializer_list<double> lst) {
        Check::error_if<std::out_of_range>(nmx_msgx(__func__), //
                                           lst.size() > N);
        //instanziiere neue Zeile
        Row crow;
        //kopiere Elemente
        std::copy(std::begin(lst), std::end(lst), std::begin(crow));
        //addiere neue Reihe zur Tabelle
        add(crow);
    }

    inline auto &operator+=(const Row &lst) {
        add(lst);
        return *this;
    }

    inline auto &operator+=(std::initializer_list<double> lst) {
        try {
            add(lst);
        } catch (...) {
            // wenn ein Fehler auftritt, enthält die Nachricht
            // den richtigen Funktionsnamen
            throw std::out_of_range(nmx_msgx(__func__));
        }
        return *this;
    }

    inline void save(std::ostream &ofs, Format fmt) const {
        for (const auto &row : _data) {
            fmt.write_line(ofs, row);
        }
    }

    template<class FN>
    void save(std::ostream &ofs, Format fmt, FN fn) const {
        for (const auto &row : _data) {
            fmt.write_line(ofs, fn(row));
        }
    }

    auto column(size_t cidx) const {
        //erzeuge Vektor mit Länge gleich der Anzahl der Reihen
        Column clmn(rows());
        for (size_t idx = 0; idx < _data.size(); idx++) {
            clmn[idx] = _data[idx][cidx];
        }
        return clmn;
    }

    inline void set_column(const Column clmn, size_t idx) {
        if (_data.empty()) { // Tabelle ist leer
            for (size_t jdx = 0; jdx < clmn.size(); jdx++) {
                Row crow; //erzeuge neue Reihe
                crow[idx] = clmn[jdx]; // setze Wert
                _data.push_back(crow); // füge Reihe hinzu
            }
        } else { //Tabelle nicht leer
            if (clmn.size() != rows()) {
                //Fehler: die neue Spalte hat nicht die gleiche Länge
                // mit der alten Spalte
                throw std::range_error(nmx_msgx(__func__));
            }
            for (size_t jdx = 0; jdx < rows(); jdx++) {
                _data[jdx][idx] = clmn[jdx]; //ersetze Wert
            }
        }
    }

    template<class FN>
    void apply(FN fn) {
        for (auto &row : _data) {
            fn(row);
        }
    }

    inline void read_csv(std::ifstream &ifs) {
        //teste Status von Eingabestrom
        Check::error_if(nmx_msg, !ifs.is_open());
        std::string line;
        while (getline(ifs, line)) {
            std::stringstream stream(line);
            std::string token;
            size_t idx = 0;
            char *ptr;
            std::array<double, N> buffer;
            while (getline(stream, token, ',')) {
                buffer[idx] = std::strtod(token.c_str(), &ptr);
                idx++;
            }
            add(buffer);
        }
    }

    inline auto view() const { return View(*this); }

    template<class PREDICATE>
    auto view(PREDICATE fn, bool f = true, bool l = true) const {
        View view(*this);
        if (f) { //füge erste Zeile der Tabelle hinzu?
            view.add(static_cast<size_t>(0));
        }
        for (size_t idx = 0; idx < rows(); idx++) {
            if (fn(_data[idx])) {
                view.add(idx); //addiere Reihenindex zur View
            }
        }
        if (l) { //füge letzte Zeile der Tabelle hinzu?
            view.add(_data.size() - 1);
        }
        return view;
    }

    inline auto view(std::initializer_list<typename Container::iterator> lst,
                     bool f = true,
                     bool l = true) {
        View view(*this);

        if (f) { //füge erste Zeile der Tabelle hinzu?
            view.add(static_cast<size_t>(0));
        }
        for (const auto &itr : lst) {
            //berechne Index
            const auto cidx = std::distance(_data.begin(), itr);
            //addiere Reihenindex zur View
            view.add(static_cast<size_t>(cidx));
        }
        if (l) { //füge letzte Zeile der Tabelle hinzu?
            view.add(_data.size() - 1);
        }
        return view;
    }

    inline auto select_rows(size_t step, size_t startidx = 0, bool last = false) const {
        View view(*this);

        for (size_t idx = startidx; idx < _data.size(); idx += step) {
            //addiere Reihenindex zur View
            view.add(idx);
        }

        if (last) { //füge letzte Zeile der Tabelle hinzu?
            view.add(_data.size() - 1);
        }
        return view;
    }

    inline auto select_total_rows(size_t n, size_t start = 0, bool l = true) const {
        //berechne Abstand zwischen den Zeilen
        const size_t stepSize = std::ceil((rows()) / (n - 1));
        return select_rows(stepSize, start, l);
    }

    template<class FN>
    inline Column column(size_t cidx, const FN &fn) {
        Column clmn;
        for (const auto &row : _data) {
            if (fn(row)) {
                clmn.push_back(row[cidx]);
            }
        }
        return clmn;
    }
}; //Data

} // namespace nmx