#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
}