array_selection.hpp

//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// libpnicore is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libpnicore.  If not, see <http://www.gnu.org/licenses/>.
// 
// ============================================================================
//
// Created on: Jun 1, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include <vector>
#include <algorithm>

#ifdef NOFOREACH
#include <boost/foreach.hpp>
#endif

#include "../utilities/container_utils.hpp"
#include "../error/exception_utils.hpp"
#include "../algorithms.hpp"
#include "slice.hpp"

namespace pni{
namespace core{


    class array_selection
    {
        private:
            typedef std::vector<size_t> index_type;

            //member variables describing the selection in the original array
            //all of these containers have the same size which is equal to the
            //rank of the original array
            index_type _oshape;             
            index_type _offset;
            index_type _stride;

        public:
            //===================constructors and destructor====================
            template<template<typename ...> class CTYPE,typename ...OTS>
            explicit array_selection(const CTYPE<OTS...> &oshape,
                                     const CTYPE<OTS...> &ooffset,
                                     const CTYPE<OTS...> &ostride):
                _oshape(oshape.size()),
                _offset(ooffset.size()),
                _stride(ostride.size())
            {
                std::copy(oshape.begin(),oshape.end(),_oshape.begin());
                std::copy(ooffset.begin(),ooffset.end(),_offset.begin());
                std::copy(ostride.begin(),ostride.end(),_stride.begin());
            }

            //------------------------------------------------------------------
            explicit array_selection(): _oshape(0), _offset(0), _stride(0)
            {}

            //-----------------------------------------------------------------
            explicit array_selection(index_type &&oshape,index_type &ooffset,
                                     index_type &&ostride):
                _oshape(std::move(oshape)),
                _offset(std::move(ooffset)),
                _stride(std::move(ostride))
            {
            }
            
            //-----------------------------------------------------------------
            explicit array_selection(const index_type &oshape,
                                     const index_type &ooffset,
                                     const index_type &ostride):
                _oshape(oshape),
                _offset(ooffset),
                _stride(ostride)
            {
            }

            //-----------------------------------------------------------------
            explicit array_selection(const array_selection &s):
                _oshape(s._oshape),
                _offset(s._offset),
                _stride(s._stride)
            { }

            //-----------------------------------------------------------------
            array_selection(array_selection &&s):
                _oshape(std::move(s._oshape)),
                _offset(std::move(s._offset)),
                _stride(std::move(s._stride))
            { }

            //-----------------------------------------------------------------
            array_selection &operator=(const array_selection &s)
            {
                if(this == &s) return *this;

                _oshape = s._oshape;
                _offset = s._offset;
                _stride = s._stride;

                return *this;
            }

            //-----------------------------------------------------------------
            array_selection &operator=(array_selection &&s)
            {
                if(this == &s) return *this;

                _oshape = std::move(s._oshape);
                _offset = std::move(s._offset);
                _stride = std::move(s._stride);

                return *this;
            }


            //-----------------------------------------------------------------
            template<typename CTYPE,
                     typename = typename std::enable_if<
                     std::is_same<typename CTYPE::value_type,pni::core::slice>::value
                     >::type
                    >
            static array_selection create(const CTYPE &s)
            {
                typedef container_utils<index_type> cutils_type;
                auto shape  = cutils_type::create(s.size());
                auto offset = cutils_type::create(s.size());
                auto stride = cutils_type::create(s.size());

                size_t index = 0;
#ifdef NOFOREACH
                BOOST_FOREACH(auto sl,s)
#else
                for(auto sl: s)
#endif
                {
                    offset[index] = sl.first();
                    stride[index] = sl.stride();
                    shape[index]  = pni::core::size(sl);
                    index++;
                }

                return array_selection(std::move(shape),
                                       std::move(offset),
                                       std::move(stride));
            }

           
            //=================inquery methods=================================
            size_t rank() const 
            { 
                return _oshape.size() - std::count(_oshape.begin(),_oshape.end(),1);
            }

            //-----------------------------------------------------------------
            template<typename CTYPE> CTYPE shape() const
            {
                typedef container_utils<CTYPE>  cutils_type;
                auto c = cutils_type::create(rank());

                //now we have to copy only those values from the original shape
                //that are not equal 1
                std::copy_if(_oshape.begin(),_oshape.end(),c.begin(),
                             [](size_t i){ return i!=1; });
                return c;
            }

            //----------------------------------------------------------------- 
            size_t size() const 
            { 
                typedef typename index_type::value_type value_type;
                if(_oshape.empty()) return 0; //not initialized 

                if(rank() == 0) return 1; //scalar element selected 

                //compute the size and return it
                return std::accumulate(_oshape.begin(),_oshape.end(),
                                      value_type(1),
                                      std::multiplies<value_type>());
            }

            //=========methods to retrieve full selection information==========
            const index_type &full_shape() const { return _oshape; }

            //-----------------------------------------------------------------
            template<typename CTYPE> CTYPE full_shape() const 
            {
                typedef container_utils<CTYPE> cutils_type; 
                auto c = cutils_type::create(_oshape.size());
                std::copy(_oshape.begin(),_oshape.end(),c.begin());
                return c;
            }

            //-----------------------------------------------------------------
            const index_type &offset() const { return _offset; }

            //-----------------------------------------------------------------
            template<typename CTYPE> CTYPE offset() const
            {
                typedef container_utils<CTYPE> cutils_type;
                auto c = cutils_type::create(_offset.size());
                std::copy(_offset.begin(),_offset.end(),c.begin());
                return c;
            }

            //-----------------------------------------------------------------
            const index_type &stride() const { return _stride; }

            //-----------------------------------------------------------------
            template<typename CTYPE> CTYPE stride() const
            {
                typedef container_utils<CTYPE> cutils_type;
                auto c = cutils_type::create(_stride.size());

                std::copy(_stride.begin(),_stride.end(),c.begin());
                return c;
            }

            //================get indices======================================

            template<
                     typename ITYPE,
                     typename OITYPE
                    > 
            void index(const ITYPE &sindex,OITYPE &oindex) const
            {
#ifdef DEBUG
                //check here if the size (rank) of the original shape of the
                //selection matches that of the original index.
                check_equal_size(_oshape,oindex,EXCEPTION_RECORD);
                //check if the size of the selection index container matches the
                //effective rank of the selection
                check_equal_size(shape<ITYPE>(),sindex,EXCEPTION_RECORD);
#endif

                //now we have to add index*stride from the selection index too
                //the appropriate locations
                auto os_iter = _oshape.begin(); //iter. over original shape
                auto st_iter = _stride.begin(); //iter. over selection strides
                auto si_iter = sindex.begin();  //iter. over selection index
                auto of_iter = _offset.begin(); //iter. over the offset

                //loop over output index
                for(auto &oi: oindex)
                {
                    size_t index = *of_iter++;
                    //oi = *of_iter++;
                    if(*os_iter++ != 1) index += (*st_iter)*(*si_iter++);
                    ++st_iter;  //need to increment this guy in any case
                    oi = index;
                }
            }

            //-----------------------------------------------------------------
            template<
                     typename OITYPE,
                     typename ITYPE
                    > 
            OITYPE index(const ITYPE &sindex) const
            {
                typedef container_utils<OITYPE> cutils_type;
                auto oindex = cutils_type::create(_oshape.size());

                try{ index(sindex,oindex); }
                EXCEPTION_FORWARD(size_mismatch_error);

                return oindex;
            }
    };

    
    //-------------------------------------------------------------------------
    template<
             typename MAPT,
             typename CTYPE
            >
    size_t offset(const MAPT &map,const array_selection &s,
                  const CTYPE &index)
    {
        //compute the original index of the selection index 
        auto orig_index = container_utils<CTYPE>::create(map.rank());
        s.index(index,orig_index);

        return map.offset(orig_index);
    }
  
    //-------------------------------------------------------------------------
    template<typename MAPT>
    size_t start_offset(const MAPT &map,const array_selection &s)
    {
        typedef std::vector<size_t> index_type;

        auto index = s.template shape<index_type>();
        //set all elements to zero
        std::fill(index.begin(),index.end(),size_t(0));

        return offset(map,s,index);
    }

    //-------------------------------------------------------------------------
    template<typename MAPT>
    size_t last_offset(const MAPT &map,const array_selection &s)
    {
        typedef std::vector<size_t> index_type;

        auto index = s.template shape<index_type>();
        std::transform(index.begin(),index.end(),index.begin(),
                       [](const size_t &i){ return i-size_t(1); });

        return offset(map,s,index);

    }

    //-------------------------------------------------------------------------
    template<typename MAPT>
    bool is_contiguous(const MAPT &map,const array_selection &s)
    {

        size_t orig_first_offset = start_offset(map,s);
        size_t orig_last_offset  = last_offset(map,s);

        //check if the size of the selection matches the offset-difference in
        //the original array - in this case we have a contiguous selection.
        if( (orig_last_offset - orig_first_offset + 1) == s.size())
            return true;

        return false;
    }
    

//end of namespace
}
}