ivl/details/corefunc/min.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_COREFUNC_MIN
#define IVL_COREFUNC_MIN

namespace ivl {

static __attribute__ ((unused)) struct min_impl : public ivl_func<min_impl>
{
        template<class J, class T, class S>
        void operate(J& s, sep, const array<T, S>& a)
        {
                s = a[0];
                for (size_t i = 1; i < a.length(); i++)
                        if (a[i] < s)
                                s = a[i];
        }

        template<class T, class S>
        T operator()(const array<T, S>& a)
        {
                return call<T>(a);
        }
        
        // ----- elem function call type

        template<class T, class J, class K>
        struct elem_class
        {
                typedef types::number<12> cost;
                typedef J default_ret_type;
                typedef typename types::t_if<types::t_eq<T, types::term>,
                        default_ret_type, T>::type func_ret_type;
                static inline func_ret_type elem_op(const J& elem1, const K& elem2)
                {
                        return math::min(elem1, elem2);
                }
        };
        

        template <class A1, class A2>
        typename binary_elem_func_result<
                typename elem_class<
                        types::term,
                        typename types::get_value<A1>::type,
                        typename types::get_value<A2>::type>::default_ret_type,
                        elem_class, A1, A2>::type operator()(
                const A1& a1, const A2& a2)
        {
                return binary_elem_func_result<
                typename elem_class<
                        types::term,
                        typename types::get_value<A1>::type,
                        typename types::get_value<A2>::type>::default_ret_type,
                        elem_class, A1, A2>::from(a1, a2);
        }

        // operate modes
        // ===============================================================
        // 
        // -------------- elem function mode
        template <class AO, class A1, class A2>
        void operate(AO& o, sep, const A1& a1, const A2& a2)
        {
                // usually () operator calls the operate.
                // however in the elem-func case, it is normal that the operate function calls the () operator
                o = (*this)(a1, a2);
        }


        // --------------

        template<class J, class I, class T, class S>
        void operate(J& s, I& imin, sep, const array<T, S>& a)
        {
                /* TODO: CHECK
                typename array<T, S>::const_iterator cit = a.begin();
                s = *cit;
                cit++;
                imin = 0;
                for (size_t i = 1; i < a.length(); i++, cit++)
                        if (*cit > s) {
                                imax = i;
                                s = *cit;
                        }
                */
                s = a[0];
                imin = 0;
                for (size_t i = 1; i < a.length(); i++)
                        if (a[i] < s) {
                                imin = i;
                                s = a[i];
                        }
        }

// --------------
        template<class J, class S1, class I, class S2, class T, class S, class E>
        void operate(array<J, S1>& s, array<I, S2>& imin, sep,
                                const array_2d<T, S>& a,
                                array<E, data::empty<> >, size_t dim)
        {
                s.resize(a.size(1 - dim));
                imin.resize(a.size(1 - dim));
/*
                for(size_t j = 0; j < a.size(1 - dim); j++) {
                        array<index_array> p = idx(j, j);
                        p[dim] = all();
                        _(s[j], imax[j]) = (*this)++(a(p));
                }
*/
                //std::cout << a << std::endl;

                if(dim == 0) {
                        for(size_t j = 0; j < a.size(1 - dim); j++) {
                                //TODO: what is this
                                std::cout << a.as_columns()[j] << std::endl;
                                (_, s[j], imin[j]) = (*this)++(a.as_columns()[j]);
                                //std::cout << s[j] << " " << imax[j] << " " << std::endl;
                        }
                } else
                        for(size_t j = 0; j < a.size(1 - dim); j++) {
                                std::cout << a.as_rows()[j] << std::endl;
                                (_, s[j], imin[j]) = (*this)++(a.as_rows()[j]);
                                //std::cout << s[j] << " " << imax[j] << " " << std::endl;
                        }

        }


} min;

template<class T, class S>
int arg_min(const array<T, S>& a)
{
        int id;
        double m;
        (_, m, id) = min++(a);
        // ivl needs (_, _, id) = max++(a);
        return id;
}


} /* namespace ivl */

#endif // IVL_COREFUNC_MIN