adaptors.hpp

Go to the documentation of this file.

#pragma once

#include "../types.hpp"
#include "../wavepackets/shapes/tiny_multi_index.hpp"


namespace waveblocks {
    namespace utilities {

        template <class Matrix>
        using grid_element_type =
            GVector<typename Matrix::Scalar, Matrix::RowsAtCompileTime>;

        template <class Matrix>
        class MatrixToGrid;

        template <class Matrix>
        class MatrixToGridIterator
        {
        private:
            MatrixToGrid<Matrix> &g;

            static const int N = Matrix::RowsAtCompileTime;
            static const int M = Matrix::ColsAtCompileTime;
            using grid_element_type = GVector<typename Matrix::Scalar, N>;
            int i;

        public:
            MatrixToGridIterator( MatrixToGrid<Matrix> &adaptor, int i )
                : g( adaptor ), i( i ) {}
            bool operator!=( MatrixToGridIterator<Matrix> other ) const {
                return other.i != i;
            }

            void operator++() {
                ++i;
            }
            grid_element_type operator*() const {
                return g[i];
            }
        };

        template <class Matrix>
        class MatrixToGrid
        {
        private:
            static const int N = Matrix::RowsAtCompileTime;
            static const int M = Matrix::ColsAtCompileTime;
            using grid_element_type = GVector<typename Matrix::Scalar, N>;

            const Matrix &matrix;

        public:
            size_t size() const {
                return M;
            }

            MatrixToGrid( const Matrix &matrix ) : matrix( matrix ) {}

            grid_element_type operator[]( int i ) const {
                return matrix.template block<N, 1>( 0, i );
            }

            MatrixToGridIterator<Matrix> begin() const {
                return MatrixToGridIterator<Matrix>( *this, 0 );
            }
            MatrixToGridIterator<Matrix> end() const {
                return MatrixToGridIterator<Matrix>( *this, M );
            }

            // "grid class template"
            template <class I>
            using type = MatrixToGrid<Matrix>;
        };


        template <class Matrix, template <typename...> class Grid = std::vector>
        Grid<grid_element_type<Matrix> > matrix_to_grid( const Matrix &m )
        {
            const int N = m.rows();
            const int M = m.cols();

            Grid<grid_element_type<Matrix> > result( M );
            auto it = result.begin();

            for ( int i = 0; i < M; ++i ) {
                *it = m.template block<N, 1>( 0, i );
                ++it;
            }

            return result;
        }
    template <class Matrix, template <typename...> class Grid = std::vector>
         Matrix grid_to_matrix( Grid<grid_element_type<Matrix> > g )
         {
             const int N = Matrix::RowsAtCompileTime;

             Matrix m;
             auto it = g.begin();

             for ( int i = 0; it != g.end(); ++i, ++it ) {
                 m.template block<N, 1>( 0, i ) = *it;
             }

             return m;
         }

        template<class Packet>
        struct PacketToCoefficients {
            static CVector<Eigen::Dynamic> to(const Packet& packet) {

                // Compute size
                int size = 0;
                for (const auto& component: packet.components()) {
                    size += component.coefficients().size();
                }
                // Allocate memory
                CVector<Eigen::Dynamic> coefficients;
                coefficients.resize(size);

                // Copy
                int j_offset = 0;
                for(auto& component : packet.components()) {
                    int j_size = component.coefficients().size();
                    for (int j = 0; j < j_size; ++j) {
                        coefficients[j+j_offset] = component.coefficients()[j];
                    }
                    j_offset += j_size;
                }

                return coefficients;
            }

            static void from(const CVector<Eigen::Dynamic>& coefficients, Packet& packet) {

                // Compute size
                int size = 0;
                for (const auto& component: packet.components()) {
                    size += component.coefficients().size();
                }

                // Copy
                int j_offset = 0;
                for(auto& component : packet.components()) {
                    int j_size = component.coefficients().size();
                    for (int j = 0; j < j_size; ++j) {
                        component.coefficients()[j] = coefficients[j+j_offset];
                    }
                    j_offset += j_size;
                }
            }
        };

        template<int D, class MultiIndex>
        struct PacketToCoefficients<wavepackets::ScalarHaWp<D,MultiIndex>> {
            static const CVector<Eigen::Dynamic>& to(const wavepackets::ScalarHaWp<D,MultiIndex>& packet) {
                return packet.coefficients();
            }

            static void from(const CVector<Eigen::Dynamic>& coefficients, wavepackets::ScalarHaWp<D,MultiIndex>& packet) {
                packet.coefficients() = coefficients;
            }

        };
    }
}