evaluations.hpp

Go to the documentation of this file.

#pragma once

#include <vector>
#include <functional>

#include "../types.hpp"


namespace waveblocks {
    namespace utilities {
        template < int N, int C,
                   template <typename, int, int> class M,
                   class A,
                   class R,
                   template <typename...> class F = std::function >
        struct FunctionMatrixEvaluator {
            static M<R, N, C> apply( const M<F<R( A )>  , N, C>& mf, const A& arg )
            {
                M<R, N, C> m;

                for ( int i = 0; i < N; ++i ) {
                    for ( int j = 0; j < C; ++j ) {
                        m( i, j ) = mf( i, j )( arg );
                    }
                }

                return m;
            }
            template<template <typename...> class G_in = std::vector,
                     template <typename...> class G_out = G_in>
            static G_out<M<R, N, C> >
            in_grid( const M<F<R( A )>, N, C>& mf,
                     G_in<A> g )
            {
                G_out<M<R, N, C> > result( g.size() );
                auto it = result.begin();

                for ( const auto & arg : g ) {
                    *it = apply( mf, arg );
                    ++it;
                }

                return result;
            }

        };

        template < template <typename, int, int> class M,
                   class A,
                   class R,
                   template <typename...> class F>
        struct FunctionMatrixEvaluator<1,1,M,A,R,F> {
            static R apply(const F<R(A)>& f, const A& arg) {
                return f(arg);
            }
            static  M<R, 1,1> apply(const M<F<R( A )>, 1,1 >& mf, const A& arg )
            {
                M<R, 1, 1> m;
                m( 0,0 ) = mf( 0,0 )( arg );

                return m;
            }

            template<   template <typename...> class G_in = std::vector,
                        template <typename...> class G_out = G_in>
            static G_out<M<R, 1,1> >
            in_grid(const M<F<R( A )>, 1,1>& mf,
                    const G_in<A>& g )
            {
                G_out<M<R, 1,1> > result( g.size() );
                auto it = result.begin();

                for ( const auto & arg : g ) {
                    *it = apply( mf, arg );
                    ++it;
                }

                return result;
            }

            template<  template <typename...> class G_in = std::vector,
                       template <typename...> class G_out = G_in>
            static G_out<R >
            in_grid( const F<R( A )>& mf,
                     const G_in<A>& g )
            {
                G_out<R > result( g.size() );
                auto it = result.begin();

                for ( const auto & arg : g ) {
                    *it = apply( mf, arg );
                    ++it;
                }

                return result;
            }
        };



        template < class A,
                   class R,
                   template <typename...> class G_in = std::vector,
                   template <typename...> class G_out = G_in,
                   template <typename...> class F = std::function >
        G_out<R> evaluate_function_in_grid( const F<R( A )>& f, const G_in<A>& g )
        {
            G_out<R> result( g.size() );
            auto it = result.begin();

            for ( const auto & arg : g ) {
                *it = f( arg );
                ++it;
            }

            return result;
        }

    }
}