RandGenerator.h

Go to the documentation of this file.

/*

License

Menge
Copyright © and trademark ™ 2012-14 University of North Carolina at Chapel Hill. 
All rights reserved.

Permission to use, copy, modify, and distribute this software and its documentation 
for educational, research, and non-profit purposes, without fee, and without a 
written agreement is hereby granted, provided that the above copyright notice, 
this paragraph, and the following four paragraphs appear in all copies.

This software program and documentation are copyrighted by the University of North 
Carolina at Chapel Hill. The software program and documentation are supplied "as is," 
without any accompanying services from the University of North Carolina at Chapel 
Hill or the authors. The University of North Carolina at Chapel Hill and the 
authors do not warrant that the operation of the program will be uninterrupted 
or error-free. The end-user understands that the program was developed for research 
purposes and is advised not to rely exclusively on the program for any reason.

IN NO EVENT SHALL THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL OR THE AUTHORS 
BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL 
DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS 
DOCUMENTATION, EVEN IF THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL OR THE 
AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL AND THE AUTHORS SPECIFICALLY 
DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AND ANY STATUTORY WARRANTY 
OF NON-INFRINGEMENT. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND 
THE UNIVERSITY OF NORTH CAROLINA AT CHAPEL HILL AND THE AUTHORS HAVE NO OBLIGATIONS 
TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

Any questions or comments should be sent to the authors {menge,geom}@cs.unc.edu

*/

#ifndef __RAND_GENERATOR_H__
#define __RAND_GENERATOR_H__

#include "CoreConfig.h"
#include "vector.h"
#include <iostream>
#include <vector>
#include "SimpleLock.h"

// Forward Declarations
class   TiXmlElement;

namespace Menge {

    namespace Math {
        MENGE_API void setDefaultGeneratorSeed( int seed );

        MENGE_API int getDefaultSeed();

        class MENGE_API FloatGenerator {
        public:
            FloatGenerator(){}

            virtual ~FloatGenerator(){}

            virtual void print( Logger & out ) const = 0;

            virtual float getValue() const = 0;
            
            virtual float getValueConcurrent() const = 0;
            
            virtual FloatGenerator * copy() const = 0;  
        };


        class MENGE_API ConstFloatGenerator : public FloatGenerator {
        public:
            ConstFloatGenerator( float value ):FloatGenerator(), _value(value){}

            virtual float getValue() const { return _value; }
            
            virtual float getValueConcurrent() const { return _value; }

            virtual void print( Logger & out ) const;
            
            virtual FloatGenerator * copy() const;  

            friend Logger & operator<<( Logger & out, const ConstFloatGenerator & gen );

        protected:
            float _value;
        };


        class MENGE_API NormalFloatGenerator : public FloatGenerator {
        public:
            NormalFloatGenerator( float mean, float stddev, float minVal, float maxVal, int seed=0 );

            void set( float mean, float stddev, float minVal, float maxVal );
            
            virtual float getValue() const;
            
            virtual float getValueConcurrent() const;

            virtual void print( Logger & out ) const;
            
            virtual FloatGenerator * copy() const;  

            friend Logger & operator<<( Logger & out, const NormalFloatGenerator & gen );

        protected:
            float _mean;

            float _std;

            float _min;
            float _max;

            mutable float   _second;

            mutable unsigned int _calls;

            mutable int   _seed;

            mutable SimpleLock  _lock;
        };


        class MENGE_API UniformFloatGenerator : public FloatGenerator {
        public:
            UniformFloatGenerator( float minVal, float maxVal, int seed=0 );

            UniformFloatGenerator( const UniformFloatGenerator & gen );

            virtual float getValue() const;
            
            virtual float getValueConcurrent() const;

            virtual void print( Logger & out ) const;
            
            virtual FloatGenerator * copy() const;  

            friend Logger & operator<<( Logger & out, const UniformFloatGenerator & gen );

            float getMin() const { return _min; }
            
            float   getMax() const { return _min + _size; }

            float getSize() const { return _size; }

        protected:
            float _min;

            float _size;

            mutable int   _seed;

            mutable SimpleLock  _lock;
        };


        class MENGE_API IntGenerator {
        public:
            IntGenerator() {}

            virtual ~IntGenerator() {}

            virtual int getValue() const = 0;
            
            virtual int getValueConcurrent() const = 0;
            
            virtual void print( Logger & out ) const = 0;
            
            virtual IntGenerator * copy() const = 0;    
        };


        class MENGE_API ConstIntGenerator : public IntGenerator {
        public:
            ConstIntGenerator( int value ): IntGenerator(),_value(value) {}

            virtual int getValue() const { return _value; }
            
            virtual int getValueConcurrent() const { return _value; }
            
            virtual void print( Logger & out ) const;
            
            virtual IntGenerator * copy() const;

            friend Logger & operator<<( Logger & out, const ConstIntGenerator & gen );

            
        protected:
            int _value;
        };


        class MENGE_API UniformIntGenerator : public IntGenerator {
        public:
            UniformIntGenerator( int minVal, int maxVal, int seed=0 );

            void setRange( int minVal, int maxVal ) { _min = minVal; _size = maxVal - minVal + 1; }

            virtual int getValue() const;
            
            virtual int getValueConcurrent() const;

            virtual void print( Logger & out ) const;
            
            virtual IntGenerator * copy() const;

            friend Logger & operator<<( Logger & out, const UniformIntGenerator & gen );

        protected:
            int _min;
            
            int _size;

            mutable int _seed;

            mutable SimpleLock  _lock;
        };



        class MENGE_API Vec2DGenerator {
        public:
            Vec2DGenerator() {}

            virtual ~Vec2DGenerator(){}

            virtual Vector2 getValue() const = 0;
            
            virtual Vector2 getValueConcurrent() const = 0;

            virtual void print( Logger & out ) const = 0;
            
            virtual Vec2DGenerator * copy() const = 0;  
        };


        class MENGE_API Zero2DGenerator : public Vec2DGenerator {
        public:
            virtual Vector2 getValue() const { return Vector2(0.f, 0.f); }
            
            virtual Vector2 getValueConcurrent() const { return Vector2(0.f, 0.f); }
            
            virtual Vec2DGenerator * copy() const { return new Zero2DGenerator(); }

            virtual void print( Logger & out ) const;
            
            friend Logger & operator<<( Logger & out, const Zero2DGenerator & gen );
        };


        class MENGE_API Const2DGenerator : public Vec2DGenerator {
        public:
            Const2DGenerator( const Vector2 & val ): Vec2DGenerator(), _value(val) {}
            
            virtual Vector2 getValue() const { return _value; }
            
            virtual Vector2 getValueConcurrent() const { return _value; }
            
            virtual void print( Logger & out ) const;
            
            virtual Vec2DGenerator * copy() const { return new Const2DGenerator( _value ); }

            friend Logger & operator<<( Logger & out, const Const2DGenerator & gen );

        protected:
            Vector2 _value;
        };


        class MENGE_API AABBUniformPosGenerator : public Vec2DGenerator {
        public:
            AABBUniformPosGenerator( const Vector2 & minPt, const Vector2 & maxPt, int seed=0 );
            
            AABBUniformPosGenerator( const AABBUniformPosGenerator & aabbGen );

            virtual Vector2 getValue() const;
            
            virtual Vector2 getValueConcurrent() const;

            virtual Vec2DGenerator * copy() const;

            virtual void print( Logger & out ) const;

            friend Logger & operator<<( Logger & out, const AABBUniformPosGenerator & gen );
        protected:
            UniformFloatGenerator   _xRand;
            
            UniformFloatGenerator   _yRand;

            mutable SimpleLock  _lock;
        };


        class MENGE_API OBBUniformPosGenerator : public Vec2DGenerator {
        public:
            OBBUniformPosGenerator( const Vector2 & minPt, const Vector2 & size, float theta, int seed=0 );
            
            OBBUniformPosGenerator( const OBBUniformPosGenerator & obbGen );

            virtual Vector2 getValue() const;
            
            virtual Vector2 getValueConcurrent() const;

            virtual void print( Logger & out ) const;

            virtual Vec2DGenerator * copy() const;

            friend Logger & operator<<( Logger & out, const OBBUniformPosGenerator & gen );

        protected:
            UniformFloatGenerator   _xRand;

            UniformFloatGenerator   _yRand;

            Vector2 _minPt;
            
            float   _cosTheta;
            
            float   _sinTheta;

            mutable SimpleLock  _lock;
        };


        class MENGE_API WeightedInt {
        public:
            WeightedInt( int value, float weight): _val(value), _wt( weight ){}

            int _val;

            float _wt;

            friend Logger & operator<<( Logger & out, const WeightedInt & wInt );
        };


        class MENGE_API WeightedIntGenerator : public IntGenerator {
        public:
            WeightedIntGenerator();

            WeightedIntGenerator( const WeightedIntGenerator & gen);

            virtual int getValue() const;
            
            virtual int getValueConcurrent() const;

            void addValue( int value, float weight );

            virtual void print( Logger & out ) const;
            
            virtual IntGenerator * copy() const;    
            
            friend Logger & operator<<( Logger & out, const WeightedIntGenerator & gen );
            
            void finalize();
        protected:

            UniformFloatGenerator _dice;

            std::vector< WeightedInt >  _pairs;

            mutable SimpleLock  _lock;
        };

        MENGE_API FloatGenerator * createFloatGenerator( TiXmlElement * node, float scale=1.f, const std::string & prefix="" );

        MENGE_API IntGenerator * createIntGenerator( TiXmlElement * node, const std::string & prefix="" );

        MENGE_API Vec2DGenerator * create2DGenerator( TiXmlElement * node, float scale=1.f );

        
    }   // namespace Math
}   // namespace Menge
#endif  // __RAND_GENERATOR_H__