ivl/details/mfunc/find.hpp

/* This file is part of the ivl C++ library <http://image.ntua.gr/ivl>.
   A C++ template library extending syntax towards mathematical notation.

   Copyright (C) 2012 Yannis Avrithis <iavr@image.ntua.gr>
   Copyright (C) 2012 Kimon Kontosis <kimonas@image.ntua.gr>

   ivl is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License 
   version 3 as published by the Free Software Foundation.

   Alternatively, you can redistribute it and/or modify it under the terms 
   of the GNU General Public License version 2 as published by the Free 
   Software Foundation.

   ivl 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 
   and a copy of the GNU Lesser General Public License along 
   with ivl. If not, see <http://www.gnu.org/licenses/>. */

#ifndef IVL_MFUNC_FIND
#define IVL_MFUNC_FIND

namespace ivl {

static  __attribute__ ((unused))
struct find_impl : public ivl_func<find_impl>
{
        template <class T1, class S1, class T2, class S2>
        void operate(array<T1, S1>& indexes, sep,
                                        const array<T2, S2>& in, const T2& what, size_t start = 0);

        template <class T, class S>
        size_array operator()(const array<T, S>& in, const T& what,
                                                size_t start = 0)
        {
                return call<size_array>(in, what, start);
        }

        template <class T1, class S1, class S2>
        void operate(array<T1, S1>& indexes, sep, const array<bool, S2>& ba);

        template <class S>
        size_array operator()(const array<bool, S>& in)
        {
                return call<size_array>(in);
        }

        template<class T1, class S1, class K1, class T2, class S2>
        void operate(array<array<size_t, K1>, S1>& indexes_nd, sep,
                const array_nd<T2, S2>& a, const T2& what);

        template<class T, class S>
        array<array<size_t, stack<3> > > operator()(
                const array_nd<T, S>& a, const T& what)
        {
                return call<
                        array<array<size_t, stack<3> > > >(a, what);
        }


        /*
        template<class T1, class S1, class S2, class S3>
        void operate(array<T1, S1>& row, array<T1, S2>& col, sep,
                const array_2d<bool, S3>& in);
        */

} find;


template <class T1, class S1, class T2, class S2>
void find_impl::operate(array<T1, S1>& indexes, sep,
                                const array<T2, S2>& in, const T2& what, size_t start)
{
        size_array a(in.length());
        size_t n = 0;
        for (size_t i = start; i < in.length(); i++)
                if (in[i] == what)
                        a[n++] = i;

        indexes = a[rng(0, n - 1)];
        //indexes.resize(n);


        // TODO: wipe these wrong parts when proved working
        indexes[*_] = a;
        indexes[rng(0, n - 1)] = a;
}

template <class T1, class S1, class S2>
void find_impl::operate(array<T1, S1>& indexes, sep, const array<bool, S2>& ba)
{
        const size_t len = ba.length();
        size_array a(len);
        size_t n = 0;

        for (size_t i = 0; i < len; i++)
                if (ba[i])
                        a[n++] = i;

        indexes = a[rng(0, n - 1)];
}

template<class T1, class S1, class K1, class T2, class S2>
void find_impl::operate(array<array<size_t, K1>, S1>& b, sep,
        const array_nd<T2, S2>& a, const T2& what)
{
        b.resize(a.length());
        size_t n = 0;

        for (size_t i = 0; i < a.length(); i++)
                if (a[i] == what)
                        b[n++] = (ind2sub(a, i));

        b.resize(n);
}

} /* namespace ivl */

#endif // IVL_MFUNC_FIND