// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// FUNCTION

// <<rand>>, <<srand>>---pseudo-random numbers

// INDEX

// rand

// INDEX

// srand

// INDEX

// _rand_r

// INDEX

// _srand_r

// ANSI_SYNOPSIS

//

// #include <stdlib.h>

// int rand(void);

// void srand(unsigned int <[seed]>);

// int _rand_r(void *<[reent]>);

// void _srand_r(void *<[reent]>, unsigned int <[seed]>);

// TRAD_SYNOPSIS

// #include <stdlib.h>

// int rand();

// void srand(<[seed]>)

// unsigned int <[seed]>;

// int _rand_r(<[reent]>);

// char *<[reent]>

// void _srand_r(<[data]>,<[seed]>)

// char *<[reent]>;

// unsigned int <[seed]>;

// <<rand>> returns a different integer each time it is called; each

// integer is chosen by an algorithm designed to be unpredictable, so

// that you can use <<rand>> when you require a random number.

// The algorithm depends on a static variable called the ``random seed'';

// starting with a given value of the random seed always produces the

// same sequence of numbers in successive calls to <<rand>>.

// You can set the random seed using <<srand>>; it does nothing beyond

// storing its argument in the static variable used by <<rand>>.  You can

// exploit this to make the pseudo-random sequence less predictable, if

// you wish, by using some other unpredictable value (often the least

// significant parts of a time-varying value) as the random seed before

// beginning a sequence of calls to <<rand>>; or, if you wish to ensure

// (for example, while debugging) that successive runs of your program

// use the same ``random'' numbers, you can use <<srand>> to set the same

// random seed at the outset.

// <<_rand_r>> and <<_srand_r>> are reentrant versions of <<rand>> and

// <<srand>>.  The extra argument <[reent]> is a pointer to a reentrancy

// structure.

// RETURNS

// <<rand>> returns the next pseudo-random integer in sequence; it is a

// number between <<0>> and <<RAND_MAX>> (inclusive).

// <<srand>> does not return a result.

// PORTABILITY

// <<rand>> is required by ANSI, but the algorithm for pseudo-random

// number generation is not specified; therefore, even if you use

// the same random seed, you cannot expect the same sequence of results

// on two different systems.

// <<rand>> requires no supporting OS subroutines.

//

#include <e32math.h>

#include <stdlib_r.h>

extern "C" {

/**

Reentrant versions of rand()

@param ptr

*/

EXPORT_C int _rand_r(struct _reent *ptr)

	{

	return Math::Rand(*(TInt64*)ptr->_next);

	}

/**

Reentrant versions of srand()

@param ptr

@param seed

*/

EXPORT_C void _srand_r (struct _reent *ptr, unsigned int seed)

	{

	ptr->_next[0] = seed;

	ptr->_next[1] = seed;

	}

/**

Returns a different integer each time it is called; each

integer is chosen by an algorithm designed to be unpredictable, so

that you can use <<rand>> when you require a random number.

@return the next pseudo-random integer in sequence; it is a

number between 0 and RAND_MAX (inclusive).

*/

EXPORT_C int rand (void)

	{

	return _rand_r (_REENT);

	}

/**

Sets the random seed.

@param seed seed

*/

EXPORT_C void srand (unsigned int seed)

	{

	_srand_r (_REENT, seed);

	}

} // extern "C"