TimeSeries.hpp

Go to the documentation of this file.

#pragma once
 
#include <ostream>
#include <Eigen/Dense>
 
namespace controlpp
{
 
    template<class T>
    class TimeSeries{
    private:
        Eigen::Vector<T, Eigen::Dynamic> times_;
        Eigen::Vector<T, Eigen::Dynamic> values_;
 
    public:
 
        TimeSeries() = default;
 
        TimeSeries(int size) : times_(size), values_(size){}
 
        TimeSeries(
            const Eigen::Vector<T, Eigen::Dynamic>& t, 
            const Eigen::Vector<T, Eigen::Dynamic>& v)
            : times_(t)
            , values_(v){}
 
        TimeSeries(
            Eigen::Vector<T, Eigen::Dynamic>&& t, 
            Eigen::Vector<T, Eigen::Dynamic>&& v)
            : times_(std::move(t))
            , values_(std::move(v)){}
 
        TimeSeries(
            const Eigen::Vector<T, Eigen::Dynamic>& t, 
            Eigen::Vector<T, Eigen::Dynamic>&& v)
            : times_(t)
            , values_(std::move(v)){}
 
        TimeSeries(
            Eigen::Vector<T, Eigen::Dynamic>&& t, 
            const Eigen::Vector<T, Eigen::Dynamic>& v)
            : times_(std::move(t))
            , values_(v){}
 
        Eigen::Vector<T, Eigen::Dynamic>& times() {return this->times_;}
        const Eigen::Vector<T, Eigen::Dynamic>& times() const {return this->times_;}
 
        T& times(size_t i){return this->times_(i);}
        const T& times(size_t i) const {return this->times_(i);}
 
        Eigen::Vector<T, Eigen::Dynamic>& values() {return this->values_;}
        const Eigen::Vector<T, Eigen::Dynamic>& values() const {return this->values_;}
 
        T& values(size_t i){return this->values_(i);}
        const T& values(size_t i) const {return this->values_(i);}
 
        TimeSeries(const TimeSeries&) = default;
        TimeSeries(TimeSeries&&) = default;
        TimeSeries& operator=(const TimeSeries&) = default;
        TimeSeries& operator=(TimeSeries&&) = default;
 
        void resize(int n){
            this->times_.resize(n);
            this->values_.resize(n);
        }
 
        size_t size() const {return std::min(this->times_.size(), this->values_.size());}
    };
 
    template<class T>
    void write_csv(std::ostream& stream, const TimeSeries<T>& timeseries){
        stream << "Times (s), Values\n";
        for(size_t i = 0; (i < timeseries.size()) && (i < timeseries.size()); ++i){
            stream << timeseries.times(i) << ", " << timeseries.values(i) << "\n";
        }
    }
 
    template<class T>
    class ComplexTimeSeries{
    public:
        Eigen::Vector<T, Eigen::Dynamic> times;
        Eigen::Vector<std::complex<T>, Eigen::Dynamic> values;
 
        ComplexTimeSeries() = default;
 
        ComplexTimeSeries(int size) : times(size), values(size) {}
 
        ComplexTimeSeries(
            const Eigen::Vector<T, Eigen::Dynamic>& t, 
            const Eigen::Vector<std::complex<T>, Eigen::Dynamic>& v)
            : times(t)
            , values(v){}
 
        ComplexTimeSeries(
            Eigen::Vector<T, Eigen::Dynamic>&& t, 
            Eigen::Vector<std::complex<T>, Eigen::Dynamic>&& v)
            : times(std::move(t))
            , values(std::move(v)){}
 
        ComplexTimeSeries(
            const Eigen::Vector<T, Eigen::Dynamic>& t, 
            Eigen::Vector<std::complex<T>, Eigen::Dynamic>&& v)
            : times(std::move(t))
            , values(std::move(v)){}
 
        ComplexTimeSeries(
            Eigen::Vector<T, Eigen::Dynamic>&& t, 
            const Eigen::Vector<std::complex<T>, Eigen::Dynamic>& v)
            : times(std::move(t))
            , values(std::move(v)){}
 
        ComplexTimeSeries(const ComplexTimeSeries&) = default;
        ComplexTimeSeries(ComplexTimeSeries&&) = default;
        ComplexTimeSeries& operator=(const ComplexTimeSeries&) = default;
        ComplexTimeSeries& operator=(ComplexTimeSeries&&) = default;
 
        void resize(int n){
            times.resize(n);
            values.resize(n);
        }
    };
 
    template<class T>
    std::ostream& operator<< (std::ostream& stream, const ComplexTimeSeries<T>& timeseries){
        stream << "Times (s), Real, Imag, Abs, Arg\n";
        for(int i = 0; (i < timeseries.times.size()) && (i < timeseries.values.size()); ++i){
            const T t = timeseries.times(i);
            const T real = std::real(timeseries.values(i));
            const T imag = std::imag(timeseries.values(i));
            const T abs = std::abs(timeseries.values(i));
            const T arg = std::arg(timeseries.values(i));
            stream << t << ", " << real << ", " << imag << ", " << abs << ", " << arg << "\n";
        }
        return stream;
    }
    
} // namespace controlpp