misc.h

Go to the documentation of this file.

#ifndef CPPAPE_MISC_H
#define CPPAPE_MISC_H
 
#include <cstdint>
#include <vector>
#include <assert.h>
#include <type_traits>
 
#include "interpolation.h"
 
namespace ape
{
    template<typename T>
    struct uarray
    {
    public:
 
        typedef T value_type;
 
        uarray(std::vector<T>& source) : uarray(source.data(), source.size()) {}
        uarray(const std::vector<typename std::remove_const_t<T>>& source) : uarray(source.data(), source.size()) {}
        uarray(T* buffer, std::size_t length)
            : buffer(buffer), length(length)
        {
#ifndef CPPAPE_RELEASE
            assert(buffer);
#endif
        }
        uarray(T* begin, T* end)
            : buffer(begin), length(end - begin)
        {
#ifndef CPPAPE_RELEASE
            assert(begin);
            assert(end);
#endif
        }
 
        T& operator [] (std::size_t index)
        {
#ifndef CPPAPE_RELEASE
            assert(index < length);
#endif
            return buffer[index];
        }
 
        const T& operator [] (std::size_t index) const
        {
#ifndef CPPAPE_RELEASE
            assert(index < length);
#endif
            return buffer[index];
        }
 
        T* begin() noexcept { return buffer; }
        const T* begin() const noexcept { return buffer; }
        T* end() noexcept { return buffer + length; }
        const T* end() const noexcept { return buffer + length; }
        T* data() noexcept { return buffer; }
        const T* data() const noexcept { return buffer; }
 
        std::size_t size() const noexcept { return length; }
        
        uarray<T> slice(std::size_t offset, std::size_t newLength = -1) noexcept
        {
            assert(offset <= length);
            if (newLength == -1)
                newLength = length - offset;
 
            assert((offset + newLength) <= length);
            return { buffer + offset, newLength };
        }
 
        template<typename Other>
        typename std::enable_if<std::is_standard_layout<Other>::value && !std::is_const<T>::value, uarray<Other>>::type
            reinterpret() noexcept
        {
            static_assert((sizeof(T) / sizeof(Other)) * sizeof(Other) == sizeof(T), "Other is not divisble by T");
            static_assert(alignof(T) <= alignof(Other), "Other is less aligned than T");
 
            constexpr auto ratio = sizeof(T) / sizeof(Other);
 
            return { reinterpret_cast<Other*>(buffer), length * ratio };
        } 
 
        template<typename Other>
        typename std::enable_if<std::is_standard_layout<Other>::value && std::is_const<T>::value, uarray<const Other>>::type
            reinterpret() const noexcept
        {
            static_assert((sizeof(T) / sizeof(Other)) * sizeof(Other) == sizeof(T), "Other is not divisble by T");
            static_assert(alignof(T) <= alignof(Other), "Other is less aligned than T");
 
            constexpr auto ratio = sizeof(T) / sizeof(Other);
 
            return { reinterpret_cast<const Other*>(buffer), length * ratio };
        }
 
        uarray<const T> slice(std::size_t offset, std::size_t newLength = -1) const noexcept
        {
            assert(offset <= length);
 
            if (newLength == -1)
                newLength = length - offset;
 
            assert((offset + newLength) <= length);
            return { buffer + offset, newLength };
        }
 
 
        operator uarray<const T>() const noexcept
        {
            return { begin(), end() };
        }
 
    private:
 
        T* const buffer;
        const std::size_t length;
    };
 
    template<typename T>
    struct umatrix
    {
    public:
 
        typedef T value_type;
 
        struct iterator
        {
            typedef std::ptrdiff_t difference_type;
            typedef T value_type;
            typedef value_type* pointer;
            typedef value_type& reference;
            typedef std::bidirectional_iterator_tag iterator_category;
 
            iterator(umatrix<T> matrix, std::size_t row = 0)
                : source(matrix), row(row)
            {
 
            }
 
            iterator& operator ++()
            {
                row++;
                return *this;
            }
 
            iterator& operator --()
            {
                row--;
                return *this;
            }
 
            iterator operator ++(int)
            {
                iterator copy{ this };
                row++;
                return copy;
            }
 
            iterator operator --(int)
            {
                iterator copy{ this };
                row--;
                return copy;
            }
 
            uarray<T> operator *()
            {
                return source[row];
            }
 
            bool operator == (const iterator& right) const noexcept
            {
                return row == right.row && source.data == right.source.data;
            }
 
            bool operator != (const iterator& right) const noexcept
            {
                return !(*this == right);
            }
 
        private:
            umatrix<T> source;
            std::size_t row;
        };
 
        umatrix(T * const * data, std::size_t channelsOrRows, std::size_t samplesOrColumns)
            : data(data)
            , numRows(channelsOrRows)
            , numColumns(samplesOrColumns)
        {
 
        }
 
        uarray<T> operator [] (std::size_t row) const CPPAPE_NOEXCEPT_IF_RELEASE
        {
#ifndef CPPAPE_RELEASE
            assert(row < numRows);
#endif
 
            return { data[row], numColumns };
        }
 
        iterator begin() const noexcept { return { *this }; }
        iterator end() const noexcept { return { *this, numRows }; }
 
        std::size_t samples() const noexcept { return numColumns; }
        std::size_t channels() const noexcept { return numRows; }
        std::size_t rows() const noexcept { return numRows; }
        std::size_t columns() const noexcept { return numColumns; }
 
        auto pointers() { return data; }
        const auto pointers() const noexcept { return data; }
 
        operator umatrix<const T> () const noexcept 
        {
            return { data, numColumns, numRows };
        }
 
    protected:
        T* const * data;
        std::size_t numRows, numColumns;
    };
 
    template<typename T>
    struct DynamicSampleMatrix
    {
        void resize(std::size_t channelCount, std::size_t samples)
        {
            channels.resize(channelCount);
            buffer.resize(channelCount * samples);
 
            for (std::size_t c = 0; c < channelCount; ++c)
                channels[c] = buffer.data() + c * samples;
        }
 
        operator umatrix<T>() noexcept
        {
            return umatrix<T> { channels.data(), channels.size(), buffer.size() / channels.size() };
        }
 
        operator umatrix<const T>() const noexcept
        {
            return umatrix<const T> { channels.data(), channels.size(), buffer.size() / channels.size() };
        }
 
        umatrix<T> asMatrix() noexcept
        {
            return umatrix<T> { channels.data(), channels.size(), buffer.size() / channels.size() };
        }
 
        std::vector<T*> channels;
        std::vector<T> buffer;
    };
 
    template<typename T>
    struct circular_signal
    {
    public:
 
        circular_signal(uarray<const T> source) : source(source) {}
 
        T operator()(std::int64_t x) const noexcept
        {
            auto mod = x % source.size();
            x = mod < 0 ? mod + source.size() : mod;
            return source[x];
        }
 
        T operator()(std::int32_t x) const noexcept
        {
            auto mod = x % source.size();
            x = mod < 0 ? mod + source.size() : mod;
            return source[x];
        }
 
        T operator()(std::uint64_t x) const noexcept
        {
            return source[x % source.size()];
        }
 
        T operator()(std::uint32_t x) const noexcept
        {
            return source[x % source.size()];
        }
 
        T operator() (double x) const noexcept
        {
            return hermite4(*this, x);
        }
 
    private:
 
        uarray<const T> source;
    };
 
    template<typename T>
    struct windowed_signal
    {
    public:
 
        windowed_signal(uarray<const T> source) : source(source) {}
 
        T operator()(std::int64_t x) const noexcept
        {
            if (x >= 0 && x < source.size())
                return source[x];
 
            return static_cast<T>(0);
        }
 
        T operator()(std::int32_t x) const noexcept
        {
            if (x >= 0 && x < source.size())
                return source[x];
 
            return static_cast<T>(0);
        }
 
        T operator()(std::uint64_t x) const noexcept
        {
            if (x < source.size())
                return source[x];
 
            return static_cast<T>(0);
        }
 
        T operator()(std::uint32_t x) const noexcept
        {
            if (x < source.size())
                return source[x];
 
            return static_cast<T>(0);
        }
 
        T operator() (double x) const noexcept
        {
            return hermite4(*this, x);
        }
 
    private:
 
        uarray<const T> source;
    };
 
    template<typename T>
    struct circular_iterator // : std::iterator<std::forward_iterator_tag, T>
    {
    public:
 
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using reference = value_type&;
        using pointer = T*;
        using iterator_category = std::forward_iterator_tag;
        using this_type = circular_iterator<T>;
 
        template<typename Container>
        friend auto cyclic_begin(Container& c, std::size_t offset);
 
        template<typename Container>
        friend auto cyclic_end(Container& c, std::size_t offset, std::size_t length);
 
        // LegacyIterator
        reference operator * () noexcept { return base[origin]; }
 
        this_type operator ++(int) noexcept
        {
            this_type copy(*this);
            ++copy;
            return copy;
        }
 
        // LegacyInputIterator
        this_type& operator ++() noexcept
        {
            if (++origin >= bounds)
                origin -= bounds;
 
            distance++;
 
            return *this;
        }
 
        pointer operator -> () noexcept { return base + origin; }
 
 
        // LegacyBidirectionalIterator
        this_type operator --(int) noexcept
        {
            this_type copy(*this);
            --copy;
            return copy;
        }
 
        // LegacyInputIterator
        this_type& operator --() noexcept
        {
            if (origin == 0)
                origin = bounds - 1;
            else
                origin--;
 
            distance--;
 
            return *this;
        }
 
 
        friend bool operator == (circular_iterator<T> left, circular_iterator<T> right)
        {
            return
                left.base == right.base &&
                left.distance == right.distance &&
                left.origin == right.origin &&
                left.bounds == right.bounds;
        }
 
        friend bool operator != (circular_iterator<T> left, circular_iterator<T> right)
        {
            return !(left == right);
        }
 
    private:
        pointer base;
        std::ptrdiff_t distance;
        std::size_t origin;
        std::size_t bounds;
    };
 
 
    template<typename Container>
    inline auto cyclic_begin(Container& c, std::size_t offset)
    {
        circular_iterator<typename Container::value_type> ret;
        ret.base = c.data();
        ret.distance = 0;
        ret.origin = offset % c.size();
        ret.bounds = c.size();
        return ret;
    }
 
    template<typename Container>
    inline auto cyclic_end(Container& c, std::size_t offset, std::size_t length)
    {
        circular_iterator<typename Container::value_type> ret;
        ret.base = c.data();
        ret.distance = length;
        ret.origin = (offset + length) % c.size();
        ret.bounds = c.size();
 
        return ret;
    }
 
    template<typename T>
    inline void clear(std::vector<T>& arr) noexcept
    {
        std::fill(arr.begin(), arr.end(), T());
    }
 
    template<typename T>
    inline typename std::enable_if<!std::is_const_v<T>>::type 
        clear(uarray<T> arr) noexcept
    {
        std::fill(arr.begin(), arr.end(), T());
    }
 
    template<typename T>
    inline typename std::enable_if<!std::is_const_v<T>>::type
        clear(umatrix<T> mat, std::size_t offset = 0) noexcept
    {
        for (std::size_t c = offset; c < mat.channels(); ++c)
        {
            clear(mat[c]);
        }
    }
 
    template<typename T>
    inline uarray<T> as_uarray(std::vector<T>& vec)
    {
        return { vec };
    }
 
    template<typename T>
    inline uarray<const T> as_uarray(const std::vector<T>& vec)
    {
        return { vec };
    }
 
    template<typename T>
    inline uarray<T> as_uarray(T* data, std::size_t size)
    {
        return { data, size };
    }
 
    template<typename T>
    inline uarray<const T> as_uarray(const T* data, std::size_t size)
    {
        return { data, size };
    }
}
 
#endif