wave_numbers.hh

#ifndef VTESTBED_CORE_WAVE_NUMBERS_HH
#define VTESTBED_CORE_WAVE_NUMBERS_HH

#include <limits>
#include <ostream>
#include <vector>

#include <vtestbed/base/blitz.hh>
#include <vtestbed/base/minmaxmean.hh>
#include <vtestbed/core/grid.hh>

namespace vtb {

    namespace core {

        template <class T>
        struct Wave_statistics {

            vtb::base::Mean<T> length;
            vtb::base::MinMaxMean<T> number;
            vtb::base::Mean<T> height;

            inline void clear() { length.clear(), number.clear(), height.clear(); }

            template <class X>
            friend std::ostream&
            operator<<(std::ostream& out, const Wave_statistics<X>& rhs);

        };

        template <class T>
        std::ostream&
        operator<<(std::ostream& out, const Wave_statistics<T>& rhs);

        template <class T, int N>
        using Wave_statistics_vector =
            blitz::TinyVector<Wave_statistics<T>,N>;

        template <class T>
        struct Wave_half {

            T length;
            T number;
            T height;

            inline
            Wave_half(T lambda, T k, T h):
            length(lambda), number(k), height(h) {}

            template <class X>
            friend std::ostream&
            operator<<(std::ostream& out, const Wave_half<X>& rhs);

        };

        template <class T>
        std::ostream&
        operator<<(std::ostream& out, const Wave_half<T>& rhs);

        template <class T>
        std::vector<blitz::TinyVector<T,2>>
        find_extrema(blitz::Array<T,1> func, const Grid<T,1>& grid);

        template <class T>
        std::vector<Wave_half<T>>
        find_wave_halves(const std::vector<blitz::TinyVector<T,2>>& extrema);

        template <class T>
        void
        find_wave_number_range(
            const std::vector<Wave_half<T>>& halves,
            T& min_wave_number,
            T& max_wave_number
        );

        template <class T>
        inline Grid<T,1>
        find_wave_number_range(const std::vector<Wave_half<T>>& halves) {
            Grid<T,1> grid{
                {std::numeric_limits<T>::max()},
                {std::numeric_limits<T>::min()},
                {2}
            };
            find_wave_number_range<T>(halves, grid.lbound(0), grid.ubound(0));
            return grid;
        }

        template <class T, int N>
        Grid<T,N>
        wave_number_grid(const Wave_statistics_vector<T,N>& waves);

        template <class T>
        Wave_statistics_vector<T,2>
        wave_statistics(blitz::Array<T,2> surface, const Grid<T,2>& grid);

        template <class T>
        Wave_statistics<T>
        temporal_wave_statistics(
            blitz::Array<T,1> surface,
            const Grid<T,1>& grid
        );

        template <class T>
        Grid<T,2>
        find_wave_number_range(blitz::Array<T,2> surface, const Grid<T,2>& grid);

    }

}

#endif // vim:filetype=cpp