Instigate Open Source Documentation

---

src/stl/_random_sample.hpp

Go to the documentation of this file.

#ifndef _INSTIGATE_STL_INTERNAL_HEADER_IN_ALGORITHM
#error This is an internal header file used to implement Instigate STL.\
        It should never be included directly by a program.
#endif

#ifndef INSTIGATE_STL_RANDOM_SAMPLE_HPP
#define INSTIGATE_STL_RANDOM_SAMPLE_HPP

// headers from this project
#include "concept.hpp"
#include "_random_number.hpp"
#include "_distance.hpp"
#include "_advance.hpp"
#include "_basis.hpp"

// headers from other project

// headers from standard library

// forward declaration
namespace instigate {
        namespace stl {
                namespace implementation {
                        template <typename I, typename R, typename D>
                        R random_sample_aux(I b, I e, R o, const D n); 
                        template <typename I, typename R, typename G, 
                                                                typename D>
                        R random_sample_aux(I b, I e, R o, G& g, const D n);
                }
                template <typename I, typename R>
                inline R random_sample(I b, I e, R f, R l);
                template <typename I, typename R, typename G>
                inline R random_sample(I b, I e, R f, R l, G& g);
        }
}


template <typename I, typename R>
R instigate::stl::random_sample(I b, I e, R f, R l)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace RA = instigate::stl::random_access_iterator;
        namespace WR = instigate::stl::writable_iterator;
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(RA::requirements<R>);
        CHECK(WR::requirements<R>);
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename WR::interface<R>::value_type value_type2;
        CHECK_CONVERTIBILITY(value_type1, value_type2);
        return instigate::stl::implementation::random_sample_aux(b, e, f, 
                        instigate::stl::distance(f, l));
}


template <typename I, typename R, typename D>
R instigate::stl::implementation::random_sample_aux(I b, I e, R o, const D n)
{
        D m = 0; 
        D t = n;
        for (; !equal(b, e) && less_than(m, n); ++m, increment(b)) {
                dereference_assign(o, const_dereference(b)); 
                increment(o);                               
        }
        D x = 0;
        assign(x, m);
        while (!equal(b, e)) {
                ++t;
                D M;
                assign(M, instigate::stl::random_number(t));
                if (less_than(M, n)) {
                        instigate::stl::advance(o, (M - x));
                        dereference_assign(o, const_dereference(b)); 
                        assign(x, M);
                }
                increment(b);
        }
        instigate::stl::advance(o, m);
        return o;
}

template <typename I, typename R, typename G>
R instigate::stl::random_sample(I b, I e, R f, R l, G& g)
{
        namespace SP = instigate::stl::single_pass_iterator;
        namespace RI = instigate::stl::readable_iterator;
        namespace RA = instigate::stl::random_access_iterator;
        namespace WR = instigate::stl::writable_iterator;
        namespace UF = instigate::stl::unary_function;
        CHECK(SP::requirements<I>);
        CHECK(RI::requirements<I>);
        CHECK(RA::requirements<R>);
        CHECK(WR::requirements<R>);
        CHECK(UF::requirements<G>);
        typedef typename RI::interface<I>::value_type value_type1;
        typedef typename WR::interface<R>::value_type value_type2;
        CHECK_CONVERTIBILITY(value_type1, value_type2);
        typedef typename RA::interface<R>::difference_type difference_type;
        typedef typename UF::interface<G>::argument_type argument_type;
        CHECK_CONVERTIBILITY(difference_type, argument_type);
        return instigate::stl::implementation::random_sample_aux(b, e, f, g, 
                        (int)instigate::stl::distance(f, l));
}

template <typename I, typename R, typename G, typename D>
R instigate::stl::implementation::random_sample_aux(I b, I e, R o, G& g, 
                                                                const D n)
{
        D m = 0; 
        D t = n;
        for (; !equal(b, e) && less_than(m, n); ++m, increment(b)) {
                dereference_assign(o, const_dereference(b)); 
                increment(o);                               
        }
        D x = 0;
        assign(x, m);
        while (!equal(b, e)) {
                ++t;
                D M = invoke(g, t);
                if (less_than(M, n)) {
                        instigate::stl::advance(o, (M - x));
                        dereference_assign(o, const_dereference(b)); 
                        assign(x, m);
                        assign(x, M);
                }
                increment(b);
        }
        instigate::stl::advance(o, m);
        return o;
}

// vim:et:tabstop=8:shiftwidth=8:cindent:fo=croq:textwidth=80:

#endif // INSTIGATE_STL_RANDOM_SAMPLE_HPP

---

© Instigate CJSC, Open Source