#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>

#include "gauss.h"

Gauss::Gauss(int seed)
{
  mSecond            = false;
  mMean              = 1;
  mStandardDeviation = 0;
  mMin = -1e20f;
  mMax = 1e20f;
  Rand::Set(seed); // init random number generator
};

Gauss::Gauss(const char *str,int seed)
{
  mSecond            = false;
  mMean              = 1;
  mStandardDeviation = 0;
  mMin = -1e20f;
  mMax = 1e20f;
  Rand::Set(seed); // init random number generator
  Set(str);
};

Gauss::~Gauss(void)
{
};

float Gauss::Get(void)
{
  float v = RandGauss()*mStandardDeviation + mMean;
  if ( v < mMin ) v = mMin;
  if ( v > mMax ) v = mMax;
  mCurrent = v;
  return v;
};

float Gauss::GetCurrent(void) const
{
  return mCurrent;
};

void Gauss::Set(float m,float s)
{
  mMean = m;
  mStandardDeviation = s;
};

// set directly.
void Gauss::Set(float m,float s,float min,float max)
{
  mMean = m;
  mStandardDeviation = s;
  mMin = min;
  mMax = max;
}

// Set from ascii string.
const char * Gauss::Set(const char *arg)
{
  char *end;
  strtogmd( (char *)arg, &end, mMean, mStandardDeviation, mMin, mMax );
  return end;
};

float Gauss::GetMean(void) const
{
  return mMean;
};

float Gauss::GetStandardDeviation(void) const
{
  return mStandardDeviation;
};

void Gauss::SetMean(float m)
{
  mMean = m;
};

void Gauss::SetStandardDeviation(float s)
{
  mStandardDeviation = s;
};

// convert gaussian into valid gaussian string.
void Gauss::GetString(char *scratch) const
{
  if ( mStandardDeviation != 0 || mMin > -1e20f || mMax <  1e20f )
  {
    if ( mMin > -1e20f || mMax < 1e20f )
      sprintf(scratch,"%0.3f:%0.3f<%0.3f:%0.3f>",mMean,mStandardDeviation,mMin,mMax);
    else
      sprintf(scratch,"%0.3f:%0.3f",mMean,mStandardDeviation);
  }
  else
  {
    sprintf(scratch,"%0.3f",mMean);
  }
};

// generate fresh gaussian pair or return last valid one.
float Gauss::RandGauss( void )
{
  if( mSecond )
  {
    mSecond = false;
    return mGauss2;
  }

  float x1;
  float x2;
  float w;
  do
  {
    x1 = 2.0f * GetFloat() - 1.0f;
    x2 = 2.0f * GetFloat() - 1.0f;
    w = x1 * x1 + x2 * x2;
  } while ( w >= 1.0f );

  w = sqrtf( (-2.0f * logf( w ) ) / w );

  mGauss1 = x1 * w;
  mGauss2 = x2 * w;

  mSecond = true;

  return mGauss1;
};


// convert string to gaussian number.  Return code
// indicates number of arguments found.
int Gauss::strtogmd(const char* spec,
                    char** end,
                    float& mean,
                    float& deviation,
                    float& min,
                    float& max ) const
{
  char* pos;
  min  = -1e20f;
  max  = 1e20f;
  mean = (float) strtod( (char*) spec, &pos );
  deviation = 0;

  if( pos == spec )
  {
    mean = 0;
    if( end != 0 )
    {
      *end = (char *)spec;
    }
    return 0;
  }
  if( *pos != ':' )
  {
    if( end != 0 )
    {
      *end = pos;
    }
    return 1;
  }
  char* devp = pos + 1;
  deviation = (float) strtod( devp, &pos );
  if( pos == devp )
  {
    if( end != 0 )
    {
      *end = devp - 1;
    }
    return 1;
  }

  if( *pos != '[' && *pos != '<' )
  {
    if( end != 0 )
    {
      *end = pos;
    }
    return 2;
  }

  char* minp = pos + 1;
  char* maxp;
  min = (float) strtod( minp, &maxp );
  if( *maxp != ',' && *maxp != ':' )
  {
    if( end != 0 )
    {
      *end = pos;
    }
    return 2;
  }
  ++maxp;
  char* endp;
  max = (float) strtod( maxp, &endp );
  if( *endp != ']' && *endp != '>' )
  {
    if( end != 0 )
    {
      *end = pos;
    }
    return 2;
  }
  if( minp == maxp - 1 )
  {
    min = -1e20f;
  }
  if( maxp == endp )
  {
    max = 1e20f;
  }
  if( end != 0 )
  {
    *end = endp + 1;
  }
  return 4;
};

 

#ifndef GAUSS_H

#define GAUSS_H

// ** This class is a Gaussian Random Number Generator
// ** A Gaussian number is expressed as having a mean and standard
// ** deviation and generates random numbers which conform to the standard
// ** bell curve distribution.  Additionally this class applies an optional
// ** minimum and maximum clamping range for all numbers generated.
// ** The Guassian class inherits the deterministic random number class.
// ** Therefore all gaussian sequences can be deterministic given the same
// ** initial random number seed.
// **
// ** The ASCII format for a gaussian number is as follows:
// **
// ** mean:std<min:max>
// **
// ** Examples of valid gaussian numbers.
// **
// **  30          (Means 30 with a standard deviation of 0)
// **  30:5        (Means 30 with a standard deviation of +/- 5)
// **  30:5<10>    (Means 30, stdev +/-5 minimum value of 10
// **  30:5<10:40> (Means 30, stdev +/-5, min value 10 max value 40)

#include "rand.h"

// Implementation of gaussian numbers.
class Gauss : public Rand
{
public:
  Gauss(int seed = 0);
  Gauss(const char *str,int seed=0);
  ~Gauss(void);

  float Get(void); // generate *deterministic* gaussian number.
  float GetCurrent(void) const; // last generated value.
  float GetMean(void) const;  // return mean.
  float GetStandardDeviation(void) const; // return standard deviation.
  void GetString(char *str) const; // get string representation


  void Set(float m,float s); // set mean and standard deviation.
  void Set(float m,float s,float min,float max); // set mean, standard deviation, min and max values.
  const char * Set(const char *arg); // set from asciiz string, returns pointer past gauss number.

  void SetMean(float m); // set just the mean.
  void SetStandardDeviation(float s); // set just the standard deviation.

  float RandGauss( void ); // construct and return gaussian number.

  // convert string to gaussian number.  Return code
  // indicates number of arguments found.
  int strtogmd(const char* spec,
               char** end,
               float& mean,
               float& deviation,
               float& min,
               float& max ) const;

  float GetMin(void) const { return mMin; };
  float GetMax(void) const { return mMax; };

private:
  float mMean;               // gaussian number has mean and
  float mStandardDeviation;  // standard deviation, also
  float mMin;                // min/max clamping values
  float mMax;

  float mCurrent;           // last got value.
  float mGauss1;            // 1st gaussian
  float mGauss2;            // 2nd gaussian
  bool  mSecond;            // have a computed second available.
};

#endif
 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gauss.h"

void main(int argc,char **argv)
{
  // Construct a deterministic Gaussian random number generator which has a mean value of 10, a standard deviation of 1, a clamped minimum value of
  // 8 and a clamped maximum value of 12
  Gauss g("10:1<8:12>",0);

  for (int i=0; i<20; i++)
  {
    float v = g.Get();
    printf("Sample: %d = %0.2f\n",i,v);
  }

}
 

#ifndef RAND_H

#define RAND_H

//** Random number class and Random number pool class.  This acts as a
//** replacement for the stdlib rand() function.  Why would you want to
//** replace the rand() function?  Because you often want a deteriminstic
//** random number generator that is exactly the same regardless of what
//** machine or compiler you build your code on.  The stdlib rand() function
//** is not guaraenteed to produce the same results on different stdlib
//** implementations.
//**
//** You can also maintain any number of unique random number generators
//** as state machines by instancing this rand class over and over again.
//**
//** The random number pool is a data structure which you allocate if you
//** want to pull items from a data set, randomly, but without any
//** duplications.  A simple example would be a deck of cards.  You would
//** instantiate the random number pool as follows:
//**
//** RandPool deck(52);
//**
//** You would then pull cards from the deck as follows:
//**
//** bool shuffled;
//** int card = deck.Get(shuffled);
//**
//** This will return a number between 0-51 (representing a card in the deck)
//** without ever reporting the same card twice until the deck has been
//** exhausted.  If the boolean 'shuffled' is true, then the deck was
//** re-shuffled on that call.  This data structure has lots of uses in
//** computer games where you want to randomly select data from a fixed
//** pool size.
//**
//** This code submitted to FlipCode.com on July 23, 2000 by John W. Ratcliff
//** It is released into the public domain on the same date.

class Rand
{
public:

	Rand(int seed=0)
  {
    mCurrent = seed;
  };

  // random number between 0 - 32767
	int Get(void)
  {
    return(((mCurrent = mCurrent * 214013L + 2531011L) >> 16) & 0x7fff);
  };

  // random number between 0.0 and 1.0
  float GetFloat(void)
  {
    return float(Get())*(1.0f/32767.0f);
  };

  void Set(int seed)
  {
    mCurrent = seed;
  };

private:
	int mCurrent;
};

class RandPool
{
public:
  RandPool(int size,int seed)  // size of random number bool.
  {
    mRand.Set(seed);       // init random number generator.
    mData = new int[size]; // allocate memory for random number bool.
    mSize = size;
    mTop  = mSize;
    for (int i=0; i<mSize; i++) mData[i] = i;
  }
  ~RandPool(void)
  {
    delete mData;
  };

  // pull a number from the random number pool, will never return the
  // same number twice until the 'deck' (pool) has been exhausted.
  // Will set the shuffled flag to true if the deck/pool was exhausted
  // on this call.
  int Get(bool &shuffled)
  {
    if ( mTop == 0 ) // deck exhausted, shuffle deck.
    {
      shuffled = true;
      mTop = mSize;
    }
    else
      shuffled = false;
    int entry = mRand.Get()%mTop;
    mTop--;
    int ret      = mData[entry]; // swap top of pool with entry
    mData[entry] = mData[mTop];  // returned
    mData[mTop]  = ret;
    return ret;
  };

private:
  Rand mRand;  // random number generator.
  int  *mData;  // random number bool.
  int   mSize;  // size of random number pool.
  int   mTop;   // current top of the random number pool.
};

#endif