array_operations.hpp

#pragma once

#include "../types/types.hpp"


namespace pni{
namespace core{

    //--------------------------------------------------------------------------
    template<typename ARRAYT> typename ARRAYT::value_type min(const ARRAYT &a) 
    {
        typedef typename ARRAYT::value_type RType;
        RType result(a[0]);

#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            auto v = *iter;
#else
        for(auto v: a)
        {
#endif
            if(v<result) result = v;
        }

        return result;
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT> typename ARRAYT::value_type max(const ARRAYT &a)
    {
        typedef typename ARRAYT::value_type RType;

        RType result(a[0]);

#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            auto v = *iter;
#else
        for(auto v: a)
        {
#endif
            if(v>result) result = v;
        }

        return result;
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT> void min_max(const ARRAYT &a,
                                           typename ARRAYT::value_type &min,
                                           typename ARRAYT::value_type &max)
    {
        min=typename ARRAYT::value_type(a[0]);
        max=typename ARRAYT::value_type(a[0]);
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            auto v=*iter;
#else
        for(auto v: a)
        {
#endif
            if(v<min) min = v;
            if(v>max) max = v;
        }
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT> void clip(ARRAYT &a,
                                        typename ARRAYT::value_type minth, 
                                        typename ARRAYT::value_type maxth)
    {
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            typename ARRAYT::value_type &v = *iter;
#else
        for(typename ARRAYT::value_type &v: a)
        {
#endif
            if(v <= minth)
            {
                v = minth;
                continue;
            }

            if(v >= maxth)
            {
                v = maxth;
                continue;
            }
        }
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT> void clip(ARRAYT &a,
                                        typename ARRAYT::value_type minth, 
                                        typename ARRAYT::value_type maxth,
                                        typename ARRAYT::value_type minval,
                                        typename ARRAYT::value_type maxval)
    {
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            typename ARRAYT::value_type &v = *iter;
#else
        for(typename ARRAYT::value_type &v: a)
        {
#endif
            if(v <= minth)
            {
                v = minval;
                continue;
            }

            if(v >= maxth)
            {
                v = maxval;
                continue;
            }
        }
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT>
    void min_clip(ARRAYT &a,typename ARRAYT::value_type threshold)
    {
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            typename ARRAYT::value_type &v = *iter;
#else
        for(typename ARRAYT::value_type &v: a)
        {
#endif
            if(v<=threshold) v = threshold;
        }
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT>
    void min_clip(ARRAYT &a,typename ARRAYT::value_type threshold,
                            typename ARRAYT::value_type value)
    {
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            typename  ARRAYT::value_type &v = *iter;
#else
        for(typename ARRAYT::value_type &v: a)
        {
#endif
            if(v<=threshold) v = value;
        }
    }
    //--------------------------------------------------------------------------
    template<typename ARRAYT> 
    void max_clip(ARRAYT &a,typename ARRAYT::value_type threshold)
    {
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            typename  ARRAYT::value_type &v = *iter;
#else
        for(typename ARRAYT::value_type &v: a)
        {
#endif
            if(v>=threshold) v = threshold;
        }
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT> 
    void max_clip(ARRAYT &a,typename ARRAYT::value_type threshold,
                            typename ARRAYT::value_type value)
    {
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            typename  ARRAYT::value_type &v = *iter;
#else
        for(typename ARRAYT::value_type &v: a)
        {
#endif
            if(v>=threshold) v = value;
        }
    }
    //--------------------------------------------------------------------------
    template<typename ARRAYT> size_t max_offset(const ARRAYT &a)
    {
        typedef typename ARRAYT::value_type value_type;
        size_t offset = 0;
        size_t index = 0;
        value_type max_value = value_type(a[0]);

        index = 0;
#ifdef NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            auto v = *iter;
#else
        for(auto v: a)
        {
#endif
            if(v > max_value)
            {
                max_value = v;
                offset  = index;
            }
            index++;
        }
        return offset;
    }

    //--------------------------------------------------------------------------
    template<typename CONT,typename ARRAYT> CONT max_index(const ARRAYT &a)
    {
        size_t offset = max_offset(a);
        return a.map().template index<CONT>(offset);
    }

    //--------------------------------------------------------------------------
    template<typename ARRAYT> size_t min_offset(const ARRAYT &a)
    {
        
        typedef typename ARRAYT::value_type value_type;
        size_t offset = 0;
        size_t index = 0;
        value_type min_value = value_type(a[0]);

        index = 0;
#ifdef  NOFOREACH
        for(auto iter=a.begin();iter!=a.end();iter++)
        {
            auto v = *iter;
#else
        for(auto v: a)
        {
#endif
            if(v < min_value)
            {
                min_value = v;
                offset  = index;
            }
            index++;
        }
        return offset;
    }

    //--------------------------------------------------------------------------
    template<typename CONT,typename ARRAYT> CONT min_index(const ARRAYT &a)
    {
        size_t offset = min_offset(a);
        return a.map().template index<CONT>(offset);
    }


//end of namespace
}
}