Stream.hpp

Go to the documentation of this file.

/*----------------------------------------------------------------------------
*
* Copyright (C) 2021 - 2024 Antonio Augusto Alves Junior
*
* This file is part of RandomIterator.
 
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ----------------------------------------------------------------------------*/
/*
 * Stream.hpp
 *
 *  Created on: 23/02/2021
 *      Author: Antonio Augusto Alves Junior
 */
 
#pragma once
 
#include <stdint.h>
 
#include "detail/tbb/iterators.h"
#include "detail/Engine.hpp"
#include "detail/functors/EngineCaller.hpp"
 
namespace random_iterator {
 
 
typedef detail::philox        philox;
typedef detail::threefry      threefry;
typedef detail::squares3_128  squares3_128;
typedef detail::squares4_128  squares4_128;
typedef detail::squares3_64   squares3_64;
typedef detail::squares4_64   squares4_64;
 
#if RANDOM_ITERATOR_R123_USE_AES_NI
typedef detail::ars           ars;
#endif
 
 
template<typename DistibutionType, typename EngineType>
class Stream
{
    typedef detail::EngineCaller<DistibutionType,EngineType>                      caller_type;
    typedef random_iterator_tbb::counting_iterator<typename EngineType::advance_type>       counting_iterator;
 
public:
 
    typedef EngineType  engine_type; 
    typedef typename    engine_type::state_type           state_type;
    typedef typename    engine_type::seed_type             seed_type;
    typedef typename    engine_type::advance_type       advance_type;
    typedef typename    engine_type::init_type             init_type;
 
    typedef DistibutionType distribution_type; 
    typedef typename  distribution_type::result_type   result_type;
 
    typedef random_iterator_tbb::transform_iterator< caller_type, counting_iterator> iterator;
 
    Stream()=delete;
 
    Stream(distribution_type const& distribution, seed_type seed, uint32_t stream=0):
        distribution_(distribution),
        engine_(seed, stream),
        seed_(seed),
        stream_(stream)
    {
        distribution_.reset();
    }
 
    Stream( Stream<DistibutionType,EngineType> const& other ):
        distribution_(other.getDistribution()),
        engine_(other.getEngine()),
        seed_(other.getSeed()),
        stream_(other.getStream())
    { }
 
    inline iterator begin() const{
 
        counting_iterator first( 0);
        caller_type caller(distribution_, seed_, stream_ );
 
        return iterator(first, caller);
    }
 
    inline iterator end() const{
 
        counting_iterator last(std::numeric_limits<advance_type>::max());
        caller_type caller(distribution_, seed_, stream_ );
 
        return iterator(last, caller) ;
    }
 
    inline result_type operator[](advance_type n) const{
 
        counting_iterator first( 0);
        caller_type caller(distribution_, seed_, stream_ );
 
        return caller(n);
    }
 
    inline result_type operator()(void){
 
        return distribution_(engine_);
    }
 
    inline distribution_type getDistribution() const {
        return distribution_;
    }
 
    inline void setDistribution(distribution_type dist) {
        distribution_ = dist;
    }
 
    inline engine_type const& getEngine() const {
        return engine_;
    }
 
    inline void setEngine(engine_type engine) {
        engine_ = engine;
    }
 
    inline const seed_type& getSeed() const {
        return seed_;
    }
 
    inline void setSeed(const seed_type& seed) {
        seed_ = seed;
    }
 
    inline uint32_t getStream() const {
        return stream_;
    }
 
    inline void setStream(uint32_t stream) {
        stream_ = stream;
    }
 
    friend inline std::ostream& operator<<(std::ostream& os, const Stream<DistibutionType, EngineType>& be){
            return  os << "engine: " << be.getEngine()
                       << " stream: "<< be.getStream()
                       << " distribution: " << be.getDistribution() ;
        }
private:
 
    distribution_type distribution_;
    engine_type             engine_;
    seed_type                 seed_;
    uint32_t                stream_;
 
};
 
template<typename DistibutionType, typename EngineType>
Stream<DistibutionType, EngineType>
make_stream( DistibutionType const& dist, EngineType const& eng, uint32_t stream ){
 
    return Stream<DistibutionType, EngineType>( dist, eng.getSeed(), stream);
}
 
 
}  // namespace random_iterator