random_iterator.h

Go to the documentation of this file.

/*
 *  Copyright 2008-2014 NVIDIA Corporation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
 
#pragma once
 
#include <cusp/detail/config.h>
 
#include <thrust/functional.h>
 
#include <thrust/iterator/counting_iterator.h>
#include <thrust/iterator/permutation_iterator.h>
#include <thrust/iterator/transform_iterator.h>
 
namespace cusp
{
 
namespace detail
{
// Forward definition
template<typename> struct random_functor_type;
template<typename,typename> struct random_integer_functor;
} // end detail
template<typename T>
class random_iterator
{
public:
 
    typedef T                                                                              value_type;
    typedef T*                                                                             pointer;
    typedef T&                                                                             reference;
    typedef size_t                                                                         difference_type;
    typedef size_t                                                                         size_type;
    typedef thrust::random_access_traversal_tag                                            iterator_category;
 
    typedef ::cuda::std::ptrdiff_t                                                                 IndexType;
    typedef detail::random_integer_functor<IndexType,T>                                    IndexFunctor;
    typedef typename thrust::counting_iterator<IndexType>                                  CountingIterator;
    typedef typename thrust::transform_iterator<IndexFunctor, CountingIterator, IndexType> RandomCountingIterator;
 
    // type of the random_range iterator
    typedef typename detail::random_functor_type<T>::type                                  Functor;
    typedef typename thrust::transform_iterator<Functor, RandomCountingIterator, T>        RandomTransformIterator;
    typedef RandomTransformIterator                                                        iterator;
    random_iterator(const size_t seed = 0)
        : random_counting_iterator(CountingIterator(0), IndexFunctor(seed)) {}
 
    iterator begin(void) const
    {
        return RandomTransformIterator(random_counting_iterator, Functor());
    }
 
    value_type operator[](size_type n) const
    {
        return *(begin() + n);
    }
 
protected:
 
    RandomCountingIterator random_counting_iterator;
}; // end random_iterator
 
} // end namespace cusp
 
#include <cusp/iterator/detail/random_iterator.inl>