#include "trandom.h"

TRandom::RANDOM_FLOAT_TYPE TRandom::RandomFloatType = TRandom::RANDOM_FLOAT_TYPE_NONE;

TRandom::TRandom(UINT _seed)

	: seed(_seed)

{

	if (RandomFloatType == TRandom::RANDOM_FLOAT_TYPE_NONE)

		setRandomFloatType();

	reset();

}

//--------------------------------------------------------------------------

TRandom::~TRandom()

{

}

//--------------------------------------------------------------------------

void TRandom::setSeed(UINT s)

{

	seed = s;

	reset();

}

//--------------------------------------------------------------------------

void TRandom::reset()

{

	UINT uj, uk;

	int i, ii, k;

	assert(sizeof(UINT) == 32 / 8);

	uj = 161803398 - seed;

	ran[55] = uj;

	uk = 1;

	for (i = 1; i <= 54; i++) {

		ii = (21 * i) % 55;

		ran[ii] = uk;

		uk = uj - uk;

		uj = ran[ii];

	}

	for (k = 1; k <= 4; k++)

		for (i = 1; i <= 55; i++)

			ran[i] -= ran[1 + (i + 30) % 55];

	idx1 = 55;

	idx2 = 31;

}

//--------------------------------------------------------------------------

inline void TRandom::setRandomFloatType()

{

	UINT u;

	assert(sizeof(float) == sizeof(UINT));

	u = 0x3f800000;

	if ((*(float *)&u) == 1.0F)

		RandomFloatType = RANDOM_FLOAT_TYPE_1;

	else {

		u = 0x0000803f;

		if ((*(float *)&u) == 1.0F)

			RandomFloatType = RANDOM_FLOAT_TYPE_2;

		else

			assert(0);

	}

}

//--------------------------------------------------------------------------

inline UINT TRandom::getNextUINT()

{

	idx1++;

	if (idx1 == 56)

		idx1 = 1;

	idx2++;

	if (idx2 == 56)

		idx2 = 1;

	ran[idx1] = ran[idx1] - ran[idx2];

	return ran[idx1];

}

//--------------------------------------------------------------------------

UINT TRandom::getUInt(UINT end) // [0,end[

{

	if (end == 0)

		return 0;

	UINT u = getNextUINT();

	if (end == c_maxuint)

		return u;

	return u % end;

}

//--------------------------------------------------------------------------

int TRandom::getInt(int begin, int end) // [begin, end[

{

	assert(end >= begin);

	int limit = end - begin;

	if (limit == 0) // end == begin

		return begin;

	UINT u = getNextUINT();

	return u % limit + begin;

}

//--------------------------------------------------------------------------

float TRandom::getFloat() // [0,1[

{

	UINT u = getNextUINT();

	switch (RandomFloatType) {

	case RANDOM_FLOAT_TYPE_1:

		u = (u >> 5) & 0x007fffff | 0x3f800000;

		break;

	case RANDOM_FLOAT_TYPE_2:

		u = u & 0xffff7f00 | 0x0000803f;

		break;

	default:

		assert(0);

		u = 0;

		break;

	}

	return (*(float *)&u) - 1.0F;

}

//--------------------------------------------------------------------------

float TRandom::getFloat(float end) // [0, end[

{

	return getFloat() * end;

}

//--------------------------------------------------------------------------

float TRandom::getFloat(float begin, float end) // [begin, end[

{

	assert(end >= begin);

	return (getFloat() * (end - begin)) + begin;

}

//--------------------------------------------------------------------------

bool TRandom::getBool()

{

	UINT u = getNextUINT();

	return u & 1;

}

//--------------------------------------------------------------------------

double TRandom::getDouble() // [0,1[

{

	return getFloat();

#ifdef DA_RIVEDERE_O_PROPRIO_IMPLEMENTARE

	UINT low = getNextUINT();

	UINT high = getNextUINT();

	double value = 0;

	void *ptr = &value;

	UINT *retL = (UINT *)ptr;

	UINT *retH = retL + 1;

/*

// questa parte e' stata commentata perche' su tutte le piattaforme il tipo

//di float e' RANDOM_FLOAT_TYPE_1ma su irix c'e' bisogno di eseguire le 

//istruzioni sotto RANDOM_FLOAT_TYPE_2

switch (RandomFloatType)

  {

  case RANDOM_FLOAT_TYPE_1:

                             *retH = high;

                             *retH &= 0x00efffff;

                             *retH |= 0x3f000000;

                             *retL = low ;

// vecchi commenti

//                             *retH = high;

//                             *retL = (low >> 5) & 0x007fffff | 0x3ff00000;

                             return value;

                             break;

   case RANDOM_FLOAT_TYPE_2: *retH = low;

                             *retL = (high >> 5) & 0x007fffff | 0x3ff00000;

                             break;

										//!!!!!occhio andrebbe sopra il break

                             return value-1.0;

  default: assert (0);  

  }

return -1;

*/

#ifndef __sgi

	*retH = high;

	*retH &= 0x007fffff;

	*retH |= 0x3ff00000;

	*retL = low;

	return value - 1.0;

#else

	*retH = low;

	*retL = (high >> 5) & 0x007fffff | 0x3ff00000;

	return value - 1.0;

#endif

#endif

}