1999-04-17 08:37:12 +08:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
2014-09-20 00:33:14 +08:00
|
|
|
| PHP Version 7 |
|
1999-04-17 08:37:12 +08:00
|
|
|
+----------------------------------------------------------------------+
|
2015-01-15 23:27:30 +08:00
|
|
|
| Copyright (c) 1997-2015 The PHP Group |
|
1999-04-17 08:37:12 +08:00
|
|
|
+----------------------------------------------------------------------+
|
2006-01-01 20:51:34 +08:00
|
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
1999-07-16 21:13:16 +08:00
|
|
|
| that is bundled with this package in the file LICENSE, and is |
|
2003-06-11 04:04:29 +08:00
|
|
|
| available through the world-wide-web at the following url: |
|
2006-01-01 20:51:34 +08:00
|
|
|
| http://www.php.net/license/3_01.txt |
|
1999-07-16 21:13:16 +08:00
|
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
|
|
| license@php.net so we can mail you a copy immediately. |
|
1999-04-17 08:37:12 +08:00
|
|
|
+----------------------------------------------------------------------+
|
2002-02-28 16:29:35 +08:00
|
|
|
| Authors: Rasmus Lerdorf <rasmus@php.net> |
|
1999-07-16 21:13:16 +08:00
|
|
|
| Zeev Suraski <zeev@zend.com> |
|
1999-04-17 08:37:12 +08:00
|
|
|
| Pedro Melo <melo@ip.pt> |
|
2001-09-16 11:46:59 +08:00
|
|
|
| Sterling Hughes <sterling@php.net> |
|
2001-09-06 03:47:55 +08:00
|
|
|
| |
|
2006-11-10 18:10:38 +08:00
|
|
|
| Based on code from: Richard J. Wagner <rjwagner@writeme.com> |
|
|
|
|
| Makoto Matsumoto <matumoto@math.keio.ac.jp> |
|
|
|
|
| Takuji Nishimura |
|
|
|
|
| Shawn Cokus <Cokus@math.washington.edu> |
|
1999-04-17 08:37:12 +08:00
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
/* $Id$ */
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
#include "php.h"
|
2000-06-14 00:31:57 +08:00
|
|
|
#include "php_math.h"
|
1999-10-07 00:34:36 +08:00
|
|
|
#include "php_rand.h"
|
1999-12-14 02:31:29 +08:00
|
|
|
|
2001-09-03 09:06:23 +08:00
|
|
|
#include "basic_functions.h"
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2001-09-17 04:49:57 +08:00
|
|
|
|
|
|
|
/* SYSTEM RAND FUNCTIONS */
|
|
|
|
|
|
|
|
/* {{{ php_srand
|
|
|
|
*/
|
2014-12-14 06:06:14 +08:00
|
|
|
PHPAPI void php_srand(zend_long seed)
|
2001-09-17 04:49:57 +08:00
|
|
|
{
|
|
|
|
#ifdef ZTS
|
|
|
|
BG(rand_seed) = (unsigned int) seed;
|
|
|
|
#else
|
|
|
|
# if defined(HAVE_SRANDOM)
|
|
|
|
srandom((unsigned int) seed);
|
|
|
|
# elif defined(HAVE_SRAND48)
|
|
|
|
srand48(seed);
|
|
|
|
# else
|
|
|
|
srand((unsigned int) seed);
|
|
|
|
# endif
|
|
|
|
#endif
|
2003-08-11 08:42:29 +08:00
|
|
|
|
|
|
|
/* Seed only once */
|
|
|
|
BG(rand_is_seeded) = 1;
|
2001-09-17 04:49:57 +08:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ php_rand
|
|
|
|
*/
|
2014-12-14 06:06:14 +08:00
|
|
|
PHPAPI zend_long php_rand(void)
|
2001-09-17 04:49:57 +08:00
|
|
|
{
|
2014-08-26 01:24:55 +08:00
|
|
|
zend_long ret;
|
2001-09-17 04:49:57 +08:00
|
|
|
|
2004-01-19 11:14:58 +08:00
|
|
|
if (!BG(rand_is_seeded)) {
|
2014-12-14 06:06:14 +08:00
|
|
|
php_srand(GENERATE_SEED());
|
2004-01-19 11:14:58 +08:00
|
|
|
}
|
|
|
|
|
2001-09-17 04:49:57 +08:00
|
|
|
#ifdef ZTS
|
|
|
|
ret = php_rand_r(&BG(rand_seed));
|
|
|
|
#else
|
|
|
|
# if defined(HAVE_RANDOM)
|
|
|
|
ret = random();
|
|
|
|
# elif defined(HAVE_LRAND48)
|
|
|
|
ret = lrand48();
|
|
|
|
# else
|
|
|
|
ret = rand();
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
|
|
/* MT RAND FUNCTIONS */
|
|
|
|
|
2001-09-06 03:47:55 +08:00
|
|
|
/*
|
2006-11-10 18:10:38 +08:00
|
|
|
The following php_mt_...() functions are based on a C++ class MTRand by
|
|
|
|
Richard J. Wagner. For more information see the web page at
|
|
|
|
http://www-personal.engin.umich.edu/~wagnerr/MersenneTwister.html
|
|
|
|
|
|
|
|
Mersenne Twister random number generator -- a C++ class MTRand
|
|
|
|
Based on code by Makoto Matsumoto, Takuji Nishimura, and Shawn Cokus
|
|
|
|
Richard J. Wagner v1.0 15 May 2003 rjwagner@writeme.com
|
|
|
|
|
|
|
|
The Mersenne Twister is an algorithm for generating random numbers. It
|
|
|
|
was designed with consideration of the flaws in various other generators.
|
|
|
|
The period, 2^19937-1, and the order of equidistribution, 623 dimensions,
|
|
|
|
are far greater. The generator is also fast; it avoids multiplication and
|
|
|
|
division, and it benefits from caches and pipelines. For more information
|
|
|
|
see the inventors' web page at http://www.math.keio.ac.jp/~matumoto/emt.html
|
|
|
|
|
|
|
|
Reference
|
|
|
|
M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
|
|
|
|
Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions on
|
|
|
|
Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
|
|
|
|
|
|
|
|
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
|
|
|
|
Copyright (C) 2000 - 2003, Richard J. Wagner
|
2015-01-03 17:22:58 +08:00
|
|
|
All rights reserved.
|
2006-11-10 18:10:38 +08:00
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions
|
|
|
|
are met:
|
|
|
|
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer in the
|
|
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
|
2015-01-03 17:22:58 +08:00
|
|
|
3. The names of its contributors may not be used to endorse or promote
|
|
|
|
products derived from this software without specific prior written
|
2006-11-10 18:10:38 +08:00
|
|
|
permission.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
2001-09-06 03:47:55 +08:00
|
|
|
*/
|
2006-11-10 18:10:38 +08:00
|
|
|
|
2001-09-06 03:47:55 +08:00
|
|
|
#define N MT_N /* length of state vector */
|
|
|
|
#define M (397) /* a period parameter */
|
|
|
|
#define hiBit(u) ((u) & 0x80000000U) /* mask all but highest bit of u */
|
|
|
|
#define loBit(u) ((u) & 0x00000001U) /* mask all but lowest bit of u */
|
|
|
|
#define loBits(u) ((u) & 0x7FFFFFFFU) /* mask the highest bit of u */
|
|
|
|
#define mixBits(u, v) (hiBit(u)|loBits(v)) /* move hi bit of u to hi bit of v */
|
|
|
|
|
2006-11-10 18:10:38 +08:00
|
|
|
#define twist(m,u,v) (m ^ (mixBits(u,v)>>1) ^ ((php_uint32)(-(php_int32)(loBit(u))) & 0x9908b0dfU))
|
|
|
|
|
|
|
|
/* {{{ php_mt_initialize
|
2001-09-06 03:47:55 +08:00
|
|
|
*/
|
2006-11-10 18:10:38 +08:00
|
|
|
static inline void php_mt_initialize(php_uint32 seed, php_uint32 *state)
|
2001-09-03 09:06:23 +08:00
|
|
|
{
|
2006-11-10 18:10:38 +08:00
|
|
|
/* Initialize generator state with seed
|
|
|
|
See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
|
|
|
|
In previous versions, most significant bits (MSBs) of the seed affect
|
|
|
|
only MSBs of the state array. Modified 9 Jan 2002 by Makoto Matsumoto. */
|
|
|
|
|
|
|
|
register php_uint32 *s = state;
|
|
|
|
register php_uint32 *r = state;
|
|
|
|
register int i = 1;
|
|
|
|
|
|
|
|
*s++ = seed & 0xffffffffU;
|
|
|
|
for( ; i < N; ++i ) {
|
|
|
|
*s++ = ( 1812433253U * ( *r ^ (*r >> 30) ) + i ) & 0xffffffffU;
|
|
|
|
r++;
|
|
|
|
}
|
2001-09-03 09:06:23 +08:00
|
|
|
}
|
2001-09-06 03:47:55 +08:00
|
|
|
/* }}} */
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2001-09-17 04:49:57 +08:00
|
|
|
/* {{{ php_mt_reload
|
|
|
|
*/
|
2014-12-14 06:06:14 +08:00
|
|
|
static inline void php_mt_reload(void)
|
2001-09-03 09:06:23 +08:00
|
|
|
{
|
2006-11-10 18:10:38 +08:00
|
|
|
/* Generate N new values in state
|
|
|
|
Made clearer and faster by Matthew Bellew (matthew.bellew@home.com) */
|
|
|
|
|
|
|
|
register php_uint32 *state = BG(state);
|
|
|
|
register php_uint32 *p = state;
|
|
|
|
register int i;
|
|
|
|
|
|
|
|
for (i = N - M; i--; ++p)
|
|
|
|
*p = twist(p[M], p[0], p[1]);
|
|
|
|
for (i = M; --i; ++p)
|
|
|
|
*p = twist(p[M-N], p[0], p[1]);
|
|
|
|
*p = twist(p[M-N], p[0], state[0]);
|
|
|
|
BG(left) = N;
|
|
|
|
BG(next) = state;
|
|
|
|
}
|
|
|
|
/* }}} */
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2006-11-10 18:10:38 +08:00
|
|
|
/* {{{ php_mt_srand
|
|
|
|
*/
|
2014-12-14 06:06:14 +08:00
|
|
|
PHPAPI void php_mt_srand(php_uint32 seed)
|
2006-11-10 18:10:38 +08:00
|
|
|
{
|
|
|
|
/* Seed the generator with a simple uint32 */
|
|
|
|
php_mt_initialize(seed, BG(state));
|
2014-12-14 06:06:14 +08:00
|
|
|
php_mt_reload();
|
2001-09-06 08:18:13 +08:00
|
|
|
|
2006-11-10 18:10:38 +08:00
|
|
|
/* Seed only once */
|
|
|
|
BG(mt_rand_is_seeded) = 1;
|
2001-09-06 03:47:55 +08:00
|
|
|
}
|
2001-09-17 04:49:57 +08:00
|
|
|
/* }}} */
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2001-09-17 04:49:57 +08:00
|
|
|
/* {{{ php_mt_rand
|
|
|
|
*/
|
2014-12-14 06:06:14 +08:00
|
|
|
PHPAPI php_uint32 php_mt_rand(void)
|
1999-04-17 08:37:12 +08:00
|
|
|
{
|
2006-11-10 18:10:38 +08:00
|
|
|
/* Pull a 32-bit integer from the generator state
|
|
|
|
Every other access function simply transforms the numbers extracted here */
|
2015-01-03 17:22:58 +08:00
|
|
|
|
2006-11-10 18:10:38 +08:00
|
|
|
register php_uint32 s1;
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2006-11-10 18:10:38 +08:00
|
|
|
if (BG(left) == 0) {
|
2014-12-14 06:06:14 +08:00
|
|
|
php_mt_reload();
|
2006-11-10 18:10:38 +08:00
|
|
|
}
|
|
|
|
--BG(left);
|
2015-01-03 17:22:58 +08:00
|
|
|
|
2006-11-10 18:10:38 +08:00
|
|
|
s1 = *BG(next)++;
|
|
|
|
s1 ^= (s1 >> 11);
|
|
|
|
s1 ^= (s1 << 7) & 0x9d2c5680U;
|
|
|
|
s1 ^= (s1 << 15) & 0xefc60000U;
|
|
|
|
return ( s1 ^ (s1 >> 18) );
|
1999-04-17 08:37:12 +08:00
|
|
|
}
|
2001-09-17 04:49:57 +08:00
|
|
|
/* }}} */
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2001-09-16 11:46:59 +08:00
|
|
|
/* {{{ proto void srand([int seed])
|
2001-09-03 09:06:23 +08:00
|
|
|
Seeds random number generator */
|
2001-09-06 03:47:55 +08:00
|
|
|
PHP_FUNCTION(srand)
|
|
|
|
{
|
2014-08-26 01:24:55 +08:00
|
|
|
zend_long seed = 0;
|
1999-09-25 20:09:50 +08:00
|
|
|
|
2014-12-14 06:06:14 +08:00
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &seed) == FAILURE)
|
2001-09-06 05:38:49 +08:00
|
|
|
return;
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2001-09-16 11:50:04 +08:00
|
|
|
if (ZEND_NUM_ARGS() == 0)
|
2001-09-16 11:46:59 +08:00
|
|
|
seed = GENERATE_SEED();
|
|
|
|
|
2014-12-14 06:06:14 +08:00
|
|
|
php_srand(seed);
|
2001-09-06 03:47:55 +08:00
|
|
|
}
|
1999-07-24 10:30:37 +08:00
|
|
|
/* }}} */
|
1999-04-17 08:37:12 +08:00
|
|
|
|
2001-09-16 11:46:59 +08:00
|
|
|
/* {{{ proto void mt_srand([int seed])
|
2001-09-06 03:47:55 +08:00
|
|
|
Seeds Mersenne Twister random number generator */
|
|
|
|
PHP_FUNCTION(mt_srand)
|
1999-04-17 08:37:12 +08:00
|
|
|
{
|
2014-08-26 01:24:55 +08:00
|
|
|
zend_long seed = 0;
|
2001-09-06 03:47:55 +08:00
|
|
|
|
2015-01-03 17:22:58 +08:00
|
|
|
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &seed) == FAILURE)
|
2001-09-06 05:38:49 +08:00
|
|
|
return;
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2001-09-16 11:50:04 +08:00
|
|
|
if (ZEND_NUM_ARGS() == 0)
|
2001-09-16 11:46:59 +08:00
|
|
|
seed = GENERATE_SEED();
|
|
|
|
|
2014-12-14 06:06:14 +08:00
|
|
|
php_mt_srand(seed);
|
2001-09-03 09:06:23 +08:00
|
|
|
}
|
|
|
|
/* }}} */
|
2001-02-22 08:24:19 +08:00
|
|
|
|
2001-09-06 04:52:45 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* A bit of tricky math here. We want to avoid using a modulus because
|
|
|
|
* that simply tosses the high-order bits and might skew the distribution
|
|
|
|
* of random values over the range. Instead we map the range directly.
|
|
|
|
*
|
|
|
|
* We need to map the range from 0...M evenly to the range a...b
|
|
|
|
* Let n = the random number and n' = the mapped random number
|
|
|
|
*
|
|
|
|
* Then we have: n' = a + n(b-a)/M
|
|
|
|
*
|
|
|
|
* We have a problem here in that only n==M will get mapped to b which
|
|
|
|
# means the chances of getting b is much much less than getting any of
|
|
|
|
# the other values in the range. We can fix this by increasing our range
|
2014-11-20 03:59:31 +08:00
|
|
|
# artificially and using:
|
2001-09-06 04:52:45 +08:00
|
|
|
#
|
|
|
|
# n' = a + n(b-a+1)/M
|
|
|
|
*
|
|
|
|
# Now we only have a problem if n==M which would cause us to produce a
|
|
|
|
# number of b+1 which would be bad. So we bump M up by one to make sure
|
|
|
|
# this will never happen, and the final algorithm looks like this:
|
|
|
|
#
|
2015-01-03 17:22:58 +08:00
|
|
|
# n' = a + n(b-a+1)/(M+1)
|
2001-09-06 04:52:45 +08:00
|
|
|
*
|
|
|
|
* -RL
|
2015-01-03 17:22:58 +08:00
|
|
|
*/
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2004-01-06 23:45:52 +08:00
|
|
|
/* {{{ proto int rand([int min, int max])
|
2001-09-06 03:47:55 +08:00
|
|
|
Returns a random number */
|
|
|
|
PHP_FUNCTION(rand)
|
2001-09-03 09:06:23 +08:00
|
|
|
{
|
2014-08-26 01:24:55 +08:00
|
|
|
zend_long min;
|
|
|
|
zend_long max;
|
|
|
|
zend_long number;
|
2001-09-06 05:38:49 +08:00
|
|
|
int argc = ZEND_NUM_ARGS();
|
2001-09-06 03:47:55 +08:00
|
|
|
|
2014-12-14 06:06:14 +08:00
|
|
|
if (argc != 0 && zend_parse_parameters(argc, "ll", &min, &max) == FAILURE)
|
2001-09-06 05:38:49 +08:00
|
|
|
return;
|
2001-02-22 08:24:19 +08:00
|
|
|
|
2014-12-14 06:06:14 +08:00
|
|
|
number = php_rand();
|
2001-09-06 04:52:45 +08:00
|
|
|
if (argc == 2) {
|
2001-09-09 18:44:12 +08:00
|
|
|
RAND_RANGE(number, min, max, PHP_RAND_MAX);
|
2001-09-06 03:47:55 +08:00
|
|
|
}
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2014-08-26 01:24:55 +08:00
|
|
|
RETURN_LONG(number);
|
2001-09-03 09:06:23 +08:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2004-01-06 23:45:52 +08:00
|
|
|
/* {{{ proto int mt_rand([int min, int max])
|
2001-09-06 03:47:55 +08:00
|
|
|
Returns a random number from Mersenne Twister */
|
|
|
|
PHP_FUNCTION(mt_rand)
|
2001-09-03 09:06:23 +08:00
|
|
|
{
|
2014-08-26 01:24:55 +08:00
|
|
|
zend_long min;
|
|
|
|
zend_long max;
|
|
|
|
zend_long number;
|
2001-09-06 05:38:49 +08:00
|
|
|
int argc = ZEND_NUM_ARGS();
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2010-11-26 00:44:20 +08:00
|
|
|
if (argc != 0) {
|
2014-12-14 06:06:14 +08:00
|
|
|
if (zend_parse_parameters(argc, "ll", &min, &max) == FAILURE) {
|
2010-11-26 00:44:20 +08:00
|
|
|
return;
|
|
|
|
} else if (max < min) {
|
2014-12-14 06:06:14 +08:00
|
|
|
php_error_docref(NULL, E_WARNING, "max(" ZEND_LONG_FMT ") is smaller than min(" ZEND_LONG_FMT ")", max, min);
|
2010-11-26 00:44:20 +08:00
|
|
|
RETURN_FALSE;
|
|
|
|
}
|
|
|
|
}
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2001-10-07 19:52:09 +08:00
|
|
|
if (!BG(mt_rand_is_seeded)) {
|
2014-12-14 06:06:14 +08:00
|
|
|
php_mt_srand(GENERATE_SEED());
|
2001-10-07 19:52:09 +08:00
|
|
|
}
|
|
|
|
|
2001-09-06 03:47:55 +08:00
|
|
|
/*
|
|
|
|
* Melo: hmms.. randomMT() returns 32 random bits...
|
|
|
|
* Yet, the previous php_rand only returns 31 at most.
|
|
|
|
* So I put a right shift to loose the lsb. It *seems*
|
2015-01-03 17:22:58 +08:00
|
|
|
* better than clearing the msb.
|
|
|
|
* Update:
|
2001-09-06 03:47:55 +08:00
|
|
|
* I talked with Cokus via email and it won't ruin the algorithm
|
|
|
|
*/
|
2014-12-14 06:06:14 +08:00
|
|
|
number = (zend_long) (php_mt_rand() >> 1);
|
2001-09-06 04:52:45 +08:00
|
|
|
if (argc == 2) {
|
2001-09-09 18:44:12 +08:00
|
|
|
RAND_RANGE(number, min, max, PHP_MT_RAND_MAX);
|
2001-09-06 03:47:55 +08:00
|
|
|
}
|
2001-09-06 04:52:45 +08:00
|
|
|
|
2014-08-26 01:24:55 +08:00
|
|
|
RETURN_LONG(number);
|
1999-04-17 08:37:12 +08:00
|
|
|
}
|
1999-07-24 10:30:37 +08:00
|
|
|
/* }}} */
|
1999-04-17 08:37:12 +08:00
|
|
|
|
1999-07-24 10:30:37 +08:00
|
|
|
/* {{{ proto int getrandmax(void)
|
|
|
|
Returns the maximum value a random number can have */
|
1999-05-16 19:19:26 +08:00
|
|
|
PHP_FUNCTION(getrandmax)
|
1999-04-17 08:37:12 +08:00
|
|
|
{
|
2008-03-11 06:15:36 +08:00
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
|
|
return;
|
2001-08-13 15:55:39 +08:00
|
|
|
}
|
|
|
|
|
2014-08-26 01:24:55 +08:00
|
|
|
RETURN_LONG(PHP_RAND_MAX);
|
1999-04-17 08:37:12 +08:00
|
|
|
}
|
1999-07-24 10:30:37 +08:00
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
/* {{{ proto int mt_getrandmax(void)
|
2001-09-06 03:47:55 +08:00
|
|
|
Returns the maximum value a random number from Mersenne Twister can have */
|
1999-05-16 19:19:26 +08:00
|
|
|
PHP_FUNCTION(mt_getrandmax)
|
1999-04-17 08:37:12 +08:00
|
|
|
{
|
2008-03-11 06:15:36 +08:00
|
|
|
if (zend_parse_parameters_none() == FAILURE) {
|
|
|
|
return;
|
2001-08-13 15:55:39 +08:00
|
|
|
}
|
|
|
|
|
2001-09-06 03:47:55 +08:00
|
|
|
/*
|
|
|
|
* Melo: it could be 2^^32 but we only use 2^^31 to maintain
|
|
|
|
* compatibility with the previous php_rand
|
|
|
|
*/
|
2014-08-26 01:24:55 +08:00
|
|
|
RETURN_LONG(PHP_MT_RAND_MAX); /* 2^^31 */
|
1999-04-17 08:37:12 +08:00
|
|
|
}
|
1999-07-24 10:30:37 +08:00
|
|
|
/* }}} */
|
2001-06-05 21:12:10 +08:00
|
|
|
|
1999-04-17 08:37:12 +08:00
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* tab-width: 4
|
|
|
|
* c-basic-offset: 4
|
|
|
|
* End:
|
2001-09-09 21:29:31 +08:00
|
|
|
* vim600: noet sw=4 ts=4 fdm=marker
|
|
|
|
* vim<600: noet sw=4 ts=4
|
1999-04-17 08:37:12 +08:00
|
|
|
*/
|