DiscreteArray.h

Go to the documentation of this file.

/**********************************************************************************************************************
This file is part of the Control Toolbox (https://github.com/ethz-adrl/control-toolbox), copyright by ETH Zurich.
Licensed under the BSD-2 license (see LICENSE file in main directory)
**********************************************************************************************************************/

#pragma once

#include <vector>
#include <iostream>

namespace ct {
namespace core {


template <class T, class Alloc = Eigen::aligned_allocator<T>>
class DiscreteArray : private std::vector<T, Alloc>
{  // private since we only want to expose selective functionality
public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    typedef T value_type;                                                   
    typedef std::vector<T, Alloc> Base;                                     
    typedef typename std::vector<T, Alloc>::iterator iterator;              
    typedef typename std::vector<T, Alloc>::const_iterator const_iterator;  

    DiscreteArray() : Base(Alloc()){};

    DiscreteArray(const DiscreteArray&& other) : Base(static_cast<const Base&&>(other)) {}
    DiscreteArray(const DiscreteArray& other) : Base(static_cast<const Base&>(other)){};


    DiscreteArray(int n, const T& value = T()) : Base(n, value){};


    DiscreteArray(iterator first, iterator last) : Base(first, last){};


    DiscreteArray(const_iterator first, const_iterator last) : Base(first, last){};

    virtual ~DiscreteArray(){};

    using Base::operator[];
    using Base::at;
    using Base::back;
    using Base::begin;
    using Base::clear;
    using Base::end;
    using Base::front;
    using Base::pop_back;
    using Base::push_back;
    using Base::reserve;
    using Base::resize;
    using Base::size;


    void swap(DiscreteArray& other) { Base::swap(static_cast<Base&>(other)); }
    DiscreteArray<T, Alloc>& operator=(const DiscreteArray<T, Alloc>& rhs)
    {
        // Check for self-assignment!
        if (this == &rhs)
            return *this;

        Base::operator=(static_cast<const Base&>(rhs));

        return *this;
    }

    inline DiscreteArray<T, Alloc> operator+(const DiscreteArray<T, Alloc>& rhs) const
    {
        if (this->size() != rhs.size())
            throw std::runtime_error("DiscreteArray.h (operator +): lhs.size() != rhs.size()");

        DiscreteArray<T, Alloc> result(this->size());  

        std::transform(this->begin(), this->end(), rhs.begin(), result.begin(), std::plus<T>());
        return result;
    }

    inline DiscreteArray<T, Alloc> operator-(const DiscreteArray<T, Alloc>& rhs) const
    {
        if (this->size() != rhs.size())
            throw std::runtime_error("DiscreteArray.h (operator -): lhs.size() != rhs.size()");

        DiscreteArray<T, Alloc> result(this->size());  

        std::transform(this->begin(), this->end(), rhs.begin(), result.begin(), std::minus<T>());
        return result;
    }

    inline DiscreteArray<T, Alloc>& operator+=(const DiscreteArray<T, Alloc>& rhs)
    {
        if (this->size() != rhs.size())
            throw std::runtime_error("DiscreteArray.h (operator +=): lhs.size() != rhs.size()");

        std::transform(this->begin(), this->end(), rhs.begin(), this->begin(), std::plus<T>());
        return *this;
    }

    inline DiscreteArray<T, Alloc>& operator-=(const DiscreteArray<T, Alloc>& rhs)
    {
        if (this->size() != rhs.size())
            throw std::runtime_error("DiscreteArray.h (operator -=): lhs.size() != rhs.size()");

        std::transform(this->begin(), this->end(), rhs.begin(), this->begin(), std::minus<T>());
        return *this;
    }

    template <typename SCALAR>
    inline DiscreteArray<T, Alloc> operator*(const SCALAR& scalar) const
    {
        DiscreteArray<T, Alloc> result(this->size());  
        std::transform(this->begin(), this->end(), result.begin(), [scalar](T arg) { return arg * scalar; });
        return result;
    }

    template <typename SCALAR>
    inline DiscreteArray<T, Alloc> operator/(const SCALAR& scalar) const
    {
        DiscreteArray<T, Alloc> result(this->size());  
        std::transform(this->begin(), this->end(), result.begin(), [scalar](T arg) { return arg / scalar; });
        return result;
    }

    Base& toImplementation() { return *this; }
    const Base& toImplementation() const { return *this; }
    void eraseFront(const size_t N) { this->erase(this->begin(), this->begin() + N); }
    void setConstant(const T& data) { std::fill(this->begin(), this->end(), data); }
    void addOffset(const T& offset)
    {
        std::for_each(this->begin(), this->end(), [&](T& val) { val += offset; });
    }
};

} /* namespace core */
} /* namespace ct */