// 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"