phrand.h

Go to the documentation of this file.

/*-*-c++-*-*****************************************************************
                          phrand.h  -  description
                             -------------------
    begin                : Tue May 14 2002
    copyright            : (C) 2002 by Peter Haase
    email                : mail@p-haase.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/


#ifndef MY_RANDOM_HEADER
#define MY_RANDOM_HEADER


#include <iostream>
#include <vector>
#include <stdexcept>

//Forward declaration not possible, so we need to
//include here:
#include <gsl/gsl_rng.h>

#include <simthetic/misc.h>


namespace simth
{

extern "C"
{
  double gsl_ran_gaussian(const gsl_rng*,double);
  double gsl_ran_rayleigh(const gsl_rng*,double);
}

class GslRandomWrapper
{

  public:

    GslRandomWrapper(const gsl_rng_type& generatorAlgorithm = *gsl_rng_taus);

    virtual ~GslRandomWrapper();

    const gsl_rng* rng() const {return rng_;}

  private:

    gsl_rng* rng_;

};



class RandomGenerator
{
  public:
    RandomGenerator() {};
    virtual ~RandomGenerator() {};
    virtual double get() const = 0;



};


class RandomGeneratorGsl : public RandomGenerator
{
  public:
    RandomGeneratorGsl(const gsl_rng_type& generatorAlgorithm = *gsl_rng_taus);

    virtual ~RandomGeneratorGsl();

  protected:

    const gsl_rng* rng() const {return rng_;}

  private:

    gsl_rng* rng_;

};


// ////////////////////////////////////////////////////////////


class GaussRng : public RandomGeneratorGsl
{
  protected:

    // variance of the random variable
    double variance_;

    double stdDev_;

  public:
    GaussRng(double variance);
    virtual ~GaussRng();

    double variance() const;

    void setVariance(double x);

    virtual double get() const;

    double get_inl() const;
};


inline double GaussRng::variance() const
{
  return variance_;
}

inline void GaussRng::setVariance(double x)
{
  if(x<0.0) {
    throw std::out_of_range("GaussRng::setVariance(double x) : variance must be non negative");
  }
  variance_ = x;
  stdDev_ = sqrt(x);
}

inline double GaussRng::get_inl() const
{
  return gsl_ran_gaussian(rng(),stdDev_); 
  // DAS SAH FALSCH AUS (variance_)!!! MUSS WOHL stdDev_ HEISSEN!!!
  // Fixed by m. lampe on 2003/01/04.
}


// ////////////////////////////////////////////////////////////


class RayleighRng : public RandomGeneratorGsl
{
  private:

    // variance of the random variable
    double sigma_;

  public:
    RayleighRng(double sigma);
    virtual ~RayleighRng();

    double sigma() const;

    void setSigma(double x);

    virtual double get() const;

    double get_inl() const;

};


inline double RayleighRng::sigma() const
{
  return sigma_;
}

inline void RayleighRng::setSigma(double x)
{
  sigma_ = x;
}

inline double RayleighRng::get_inl() const
{
  return gsl_ran_rayleigh(rng(),sigma_);
  //old: return sqrt(- 2 * variance_ * log( (*uni)() ));
}


// ////////////////////////////////////////////////////////////


class JakesRng : public RandomGeneratorGsl
{

  public:
    JakesRng(double df_max);

    virtual double get() const;

    double get_inl() const;

    double maxDoppler() const {return dopp_freq_max;}

  private:
    double dopp_freq_max;


};


inline double JakesRng::get_inl() const
{
  double uni = gsl_rng_uniform(rng());
  return dopp_freq_max * cos(PI2*uni);
}



// ////////////////////////////////////////////////////////////


class UniformRng : public RandomGeneratorGsl
{

  public:
    UniformRng();
    virtual ~UniformRng();

    virtual double get() const;

    double get_inl() const;

};


inline double UniformRng::get_inl() const
{
  return gsl_rng_uniform(rng());
}




// ////////////////////////////////////////////////////////////


class ExponentialMaxLimitRng : public RandomGeneratorGsl
{

  public:

    ExponentialMaxLimitRng(double lambda, double Tmax);

    virtual ~ExponentialMaxLimitRng();

    virtual double get() const;

    double attenuationFactor() const {return lambda;}

    /* Maximal value that can be returned by get().
    */
    double maxLimit() const {return Tmax;}


  private:
    double lambda;

    /* Maximal value of get()
    */
    double Tmax;

    double oneOverLambda;

    double oneMinusExpMaxX;

};



// ////////////////////////////////////////////////////////////



class DiscreteUniformRng : public RandomGeneratorGsl
{
  private:
    typedef std::vector<double> container_type;
    container_type values;

  public:

    DiscreteUniformRng(size_t K);
    virtual ~DiscreteUniformRng();

    virtual double get() const;

    double get_inl() const;

    void refresh(size_t K = 0);

};


inline double DiscreteUniformRng::get_inl() const
{
    return values[unsigned(double(values.size())*gsl_rng_uniform(rng()))];
}

}


#endif

---