convolution.hh

#ifndef VTESTBED_CORE_CONVOLUTION_HH
#define VTESTBED_CORE_CONVOLUTION_HH

#include <stdexcept>

#include <vtestbed/base/blitz.hh>
#include <vtestbed/core/fourier_transform.hh>

namespace vtb {

    namespace core {

        template <class T, int N>
        class Convolution {

        public:
            typedef Fourier_transform<T,N> transform_type;
            typedef typename transform_type::shape_type shape_type;
            typedef typename transform_type::array_type array_type;
            typedef blitz::RectDomain<N> domain_type;

        private:
            shape_type _blockshape;
            shape_type _padding;
            transform_type _fft;

        public:

            Convolution() = default;

            inline explicit
            Convolution(
                const shape_type& signal_shape,
                const shape_type& kernel_shape
            ) {
                this->shape(signal_shape, kernel_shape);
            }

            void
            shape(const shape_type& signal_shape, const shape_type& kernel_shape);

            inline void
            padded_block_shape(const shape_type& block_size, const shape_type& padding) {
                this->check(block_size, padding);
                this->_blockshape = block_size;
                this->_padding = padding;
                this->_fft.shape(this->padded_block_shape());
            }

            inline shape_type
            padded_block_shape() const noexcept {
                return this->_blockshape + this->_padding;
            }

            inline const shape_type&
            block_shape() const noexcept {
                return this->_blockshape;
            }

            inline const shape_type&
            padding() const noexcept {
                return this->_padding;
            }

            inline array_type
            operator()(array_type signal, array_type kernel) {
                return this->convolve(signal, kernel);
            }

            array_type
            convolve(array_type signal, array_type kernel);

        private:

            static inline void
            check(const shape_type& blocksize, const shape_type& padding) {
                using blitz::all;
                if (!all(padding >= 0)) {
                    throw std::length_error("bad padding");
                }
                if (!all(blocksize > 0)) {
                    throw std::length_error("bad block size");
                }
                if (!all(blocksize >= padding)) {
                    throw std::length_error("bad block size/padding ratio");
                }
                if (!all(is_power_of_two(blocksize + padding))) {
                    throw std::length_error("bad padded block size");
                }
            }

            shape_type
            get_block_shape(
                const shape_type& signal_shape,
                const shape_type& kernel_shape
            );

        };

    }

}

#endif // vim:filetype=cpp