biquad_cascade.hpp

Go to the documentation of this file.

/*
 * eDSP, A cross-platform Digital Signal Processing library written in modern C++.
 * Copyright (C) 2018 Mohammed Boujemaoui Boulaghmoudi, All rights reserved.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along width
 * this program.  If not, see <http://www.gnu.org/licenses/>
 *
 * File: biquad_cascade.hpp
 * Author: Mohammed Boujemaoui
 * Date: 30/8/2018
 */
#ifndef EDSP_BIQUAD_CASCADE_HPP
#define EDSP_BIQUAD_CASCADE_HPP

#include <edsp/meta/expects.hpp>
#include <edsp/meta/ensure.hpp>
#include <edsp/filter/biquad.hpp>
#include <array>
#include <edsp/meta/iterator.hpp>

namespace edsp { namespace filter {

    template <typename T, std::size_t N>
    class biquad_cascade {
    public:
        using value_type      = biquad<T>;
        using reference       = value_type&;
        using const_reference = const value_type&;
        using iterator        = value_type*;
        using const_iterator  = const value_type*;
        using size_type       = std::size_t;

        constexpr biquad_cascade() = default;

        ~biquad_cascade() = default;

        constexpr size_type size() const noexcept;

        constexpr size_type max_size() const noexcept;

        constexpr size_type capacity() const noexcept;

        constexpr void clear();

        constexpr void reset();

        constexpr const_reference operator[](size_type index) const noexcept;

        constexpr reference operator[](size_type index) noexcept;

        constexpr iterator begin() noexcept;

        constexpr iterator end() noexcept;

        constexpr const_iterator cbegin() const noexcept;

        constexpr const_iterator begin() const noexcept;

        constexpr const_iterator cend() const noexcept;

        constexpr const_iterator end() const noexcept;

        template <typename InputIt, typename OutputIt>
        constexpr void filter(InputIt first, InputIt last, OutputIt d_first);

        constexpr T tick(T value) noexcept;

        constexpr void push_back(const biquad<T>& biquad);

        template <typename... Arg>
        constexpr void emplace_back(Arg... arg);

    private:
        std::size_t num_stage_{0};
        std::array<biquad<T>, N> cascade_{};
    };

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::size_type biquad_cascade<T, N>::size() const noexcept {
        return num_stage_;
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::size_type biquad_cascade<T, N>::max_size() const noexcept {
        return N;
    }

    template <typename T, size_t N>
    template <typename... Arg>
    constexpr void biquad_cascade<T, N>::emplace_back(Arg... arg) {
        meta::ensure(num_stage_ < N, "No space available");
        cascade_[num_stage_] = biquad<T>(arg...);
        num_stage_++;
    }

    template <typename T, size_t N>
    constexpr void biquad_cascade<T, N>::push_back(const biquad<T>& biquad) {
        meta::ensure(num_stage_ < N, "No space available");
        cascade_[num_stage_] = biquad;
        num_stage_++;
    }

    template <typename T, size_t N>
    constexpr T biquad_cascade<T, N>::tick(T value) noexcept {
        for (auto i = 0ul; i < num_stage_; ++i) {
            value = cascade_[i].tick(value);
        }
        return value;
    }

    template <typename T, size_t N>
    template <typename InputIt, typename OutputIt>
    constexpr void biquad_cascade<T, N>::filter(InputIt first, InputIt last, OutputIt d_first) {
        for (; first != last; ++first, ++d_first) {
            *d_first = tick(*first);
        }
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::const_iterator biquad_cascade<T, N>::end() const noexcept {
        return std::cbegin(cascade_) + size();
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::const_iterator biquad_cascade<T, N>::cend() const noexcept {
        return std::cbegin(cascade_) + size();
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::const_iterator biquad_cascade<T, N>::begin() const noexcept {
        return std::cbegin(cascade_);
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::const_iterator biquad_cascade<T, N>::cbegin() const noexcept {
        return std::cbegin(cascade_);
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::iterator biquad_cascade<T, N>::end() noexcept {
        return std::begin(cascade_) + size();
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::iterator biquad_cascade<T, N>::begin() noexcept {
        return std::begin(cascade_);
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::reference biquad_cascade<T, N>::
        operator[](biquad_cascade::size_type index) noexcept {
        return cascade_[index];
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::const_reference biquad_cascade<T, N>::
        operator[](biquad_cascade::size_type index) const noexcept {
        return cascade_[index];
    }

    template <typename T, size_t N>
    constexpr void biquad_cascade<T, N>::reset() {
        for (auto i = 0ul; i < num_stage_; ++i) {
            cascade_[i].reset();
        }
    }

    template <typename T, size_t N>
    constexpr void biquad_cascade<T, N>::clear() {
        num_stage_ = 0;
    }

    template <typename T, size_t N>
    constexpr typename biquad_cascade<T, N>::size_type biquad_cascade<T, N>::capacity() const noexcept {
        return N;
    }
}}     // namespace edsp::filter
#endif // EDSP_BIQUAD_CASCADE_HPP