random.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Anthony J. Greenberg
 *
 * 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.
 */
 
 
#ifndef random_hpp
#define random_hpp
 
#include <cstdint>
 
namespace sampFiles {
    class RanDraw;
    class Generate;
    class GenerateHR;
    class GenerateMT;
    
    class Generate {
    protected:
        Generate(){};
        Generate(const Generate &old){};
        Generate(Generate &&old){};
        Generate & operator= (const Generate &old) = default;
        Generate & operator= (Generate &&old) = default;
 
    public:
        virtual ~Generate(){};
        virtual volatile uint64_t ranInt() = 0;
    };
    
    class GenerateHR : public Generate {
    protected:
        // no protected members
    public:
        GenerateHR(){};
        ~GenerateHR(){};
        GenerateHR(const GenerateHR &old){};
        GenerateHR(GenerateHR &&old){};
        GenerateHR & operator= (const GenerateHR &old) = default;
        GenerateHR & operator= (GenerateHR &&old) = default;
        
        volatile uint64_t ranInt();
    };
    
    class GenerateMT : public Generate {
    protected:
        static const unsigned short _n;
        static const unsigned short _m;
        static const uint64_t _um;
        static const uint64_t _lm;
        static const uint64_t _b;
        static const uint64_t _c;
        static const uint64_t _d;
        static const unsigned int _l;
        static const unsigned int _s;
        static const unsigned int _t;
        static const unsigned int _u;
        static const uint64_t _alt[2];
        uint64_t _mt[312];
        size_t _mti;
        uint64_t _x;
        
    public:
        GenerateMT();
        ~GenerateMT(){};
        GenerateMT(const GenerateMT &old) = default;
        GenerateMT(GenerateMT &&old) = default;
        GenerateMT & operator= (const GenerateMT &old) = default;
        GenerateMT & operator= (GenerateMT &&old) = default;
        
        volatile uint64_t ranInt();
    };
 
    class RanDraw {
    private:
        Generate *_rng;
        
    public:
        RanDraw();
        
        ~RanDraw(){ delete _rng; };
        RanDraw(const RanDraw &old) = default;
        RanDraw(RanDraw &&old) = default;
        
        RanDraw & operator= (const RanDraw &old) = default;
        RanDraw & operator= (RanDraw &&old) = default;
        
        volatile uint64_t ranInt(){ return _rng->ranInt(); };
        
        volatile double runif() {return 5.42101086242752217E-20*static_cast<double>(_rng->ranInt()); };
        volatile double runifnz();
        volatile uint64_t vitterA(const double &n, const double &N);
        volatile uint64_t vitter(const double &n, const double &N);
    };
 
}
 
#endif /* random_hpp */