ivl/details/mfunc/rand.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_RAND
#define IVL_MFUNC_RAND

namespace ivl {

namespace core_details {

template <class J, class J1, class J2>
struct rand_
{
        typedef types::number<0> cost;
        static inline double elem_op(double min, double max)
        {
                return ivl::math::rand(min, max);
        }
};

} // namespace core_details

static __attribute__ ((unused)) struct rand_impl : public ivl_func<rand_impl>,
        public binary_elem_base<double, double, double, core_details::rand_>
{
        typedef binary_elem_base<double, double, double, core_details::rand_> rand_base;

        using rand_base::operator[];
        //using randb::operator();

        
        array<double> operator()(size_t s)
        {
                array<double> c(s);
                for (size_t i = 0; i < c.length(); i++)
                        c[i] = std::rand() / (double)RAND_MAX;
                return c;
        }
        
        template<class T>
        array<T> operator()(size_t s, const T& from, const T& to)
        {
                CHECK(to >= from, ecomp); // TODO: different kind of exception here...

                array<T> c(s);
                for (size_t i = 0; i < c.length(); ++i)
                        c[i] = ivl::math::rand(from, to);
                return c;
        }

        T operator()(const T& from, const T& to)
        {
                return ivl::math::rand(from, to);
        }

        template <class T, class D>
        inline
        array_nd<T> type(const array<size_t, D>& sz)
        {
                array_nd<T> a(sz);
                for (size_t i = 0; i < a.length(); i++)
                        a[i] = std::rand();
                return a;
        }


        template <class T, class D>
        inline
        array_nd<T> operator()(const array<size_t, D>& sz)
        {
                array_nd<T> a(sz);
                for (size_t i = 0; i < a.length(); i++)
                        a[i] = std::rand();
                return a;
        }


} rand, rnd, random;

} /* namespace ivl */

#endif // IVL_MFUNC_RAND