clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-22 02:17:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

revert bad commit.

Browse Source
This commit is contained in:
foobar 2001-09-05 19:47:55 +00:00
parent 24b54b866f
commit 42b5521af5
13 changed files with 342 additions and 656 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ext/standard/Makefile.in
View File

@ -5,8 +5,7 @@ LTLIBRARY_SOURCES=\
dir.c dl.c dns.c exec.c file.c filestat.c flock_compat.c \
formatted_print.c fsock.c head.c html.c image.c info.c iptc.c lcg.c \
link.c mail.c math.c md5.c metaphone.c microtime.c pack.c pageinfo.c \
parsedate.c quot_print.c rand.c rand_sys.c rand_mt.c reg.c \
soundex.c string.c scanf.c \
parsedate.c quot_print.c rand.c reg.c soundex.c string.c scanf.c \
syslog.c type.c uniqid.c url.c url_scanner.c var.c assert.c \
strnatcmp.c levenshtein.c incomplete_class.c url_scanner_ex.c \
ftp_fopen_wrapper.c http_fopen_wrapper.c php_fopen_wrapper.c credits.c

26
ext/standard/array.c
View File

@ -1376,15 +1376,12 @@ PHP_FUNCTION(range)
/* }}} */
static int array_data_shuffle(const void *a, const void*b)
{
TSRMLS_FETCH();
return php_rand_range(0,1 TSRMLS_CC) ? 1 : -1;
static int array_data_shuffle(const void *a, const void*b) {
return (php_rand() % 2) ? 1 : -1;
}
/* {{{ proto bool shuffle(array array_arg)
/* {{{ proto int shuffle(array array_arg)
Randomly shuffle the contents of an array */
PHP_FUNCTION(shuffle)
{
@ -2719,12 +2716,10 @@ PHP_FUNCTION(array_multisort)
/* {{{ proto mixed array_rand(array input [, int num_req])
Return key/keys for random entry/entries in the array */
/* FIXME:The algorithm used is bogus! */
PHP_FUNCTION(array_rand)
{
zval **input, **num_req;
double randval;
long randval;
int num_req_val, num_avail, key_type;
char *string_key;
uint string_key_len;
@ -2763,10 +2758,17 @@ PHP_FUNCTION(array_rand)
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(input), &pos);
while (num_req_val && (key_type = zend_hash_get_current_key_ex(Z_ARRVAL_PP(input), &string_key, &string_key_len, &num_key, 0, &pos)) != HASH_KEY_NON_EXISTANT) {
#ifdef HAVE_RANDOM
randval = random();
#else
#ifdef HAVE_LRAND48
randval = lrand48();
#else
randval = rand();
#endif
#endif
randval = php_drand(TSRMLS_C);
if (randval < (double)num_req_val/(double)num_avail) {
if ((double)(randval/(PHP_RAND_MAX+1.0)) < (double)num_req_val/(double)num_avail) {
/* If we are returning a single result, just do it. */
if (Z_TYPE_P(return_value) != IS_ARRAY) {
if (key_type == HASH_KEY_IS_STRING) {

7
ext/standard/basic_functions.c
View File

@ -25,6 +25,7 @@
#include "php_ini.h"
#include "internal_functions_registry.h"
#include "php_standard.h"
#include "php_math.h"
#include "php_incomplete_class.h"
#include "ext/standard/info.h"
#include "ext/session/php_session.h"
@ -950,7 +951,6 @@ PHP_MINIT_FUNCTION(basic)
PHP_MINIT(crypt) (INIT_FUNC_ARGS_PASSTHRU);
#endif
PHP_MINIT(rand)(INIT_FUNC_ARGS_PASSTHRU);
#ifdef ZTS
PHP_MINIT(lcg) (INIT_FUNC_ARGS_PASSTHRU);
#endif
@ -1030,6 +1030,10 @@ PHP_RINIT_FUNCTION(basic)
#endif
BG(user_shutdown_function_names) = NULL;
#if HAVE_CRYPT
PHP_RINIT(crypt) (INIT_FUNC_ARGS_PASSTHRU);
#endif
#ifndef ZTS
PHP_RINIT(lcg) (INIT_FUNC_ARGS_PASSTHRU);
#endif
@ -1037,7 +1041,6 @@ PHP_RINIT_FUNCTION(basic)
PHP_RINIT(filestat) (INIT_FUNC_ARGS_PASSTHRU);
PHP_RINIT(syslog) (INIT_FUNC_ARGS_PASSTHRU);
PHP_RINIT(dir) (INIT_FUNC_ARGS_PASSTHRU);
PHP_RINIT(rand) (INIT_FUNC_ARGS_PASSTHRU);
return SUCCESS;
}

7
ext/standard/basic_functions.h
View File

@ -170,13 +170,6 @@ typedef struct {
struct stat lsb;
/* rand.c */
int rand_generator; /* current ini-setting */
int rand_generator_current; /* current (by overriding by [mt_]srand) */
/* rand_sys.c */
unsigned int rand_sys_seed; /* Current seed for system-rand() (necessary for thread-safety) */
/* rand_mt.c */
php_uint32 state[MT_N+1]; /* state vector + 1 extra to not violate ANSI C */
php_uint32 *next; /* next random value is computed from here */
int left; /* can *next++ this many times before reloading */

12
ext/standard/crypt.c
View File

@ -89,6 +89,8 @@ extern char *crypt(char *__key, char *__salt);
#define PHP_CRYPT_RAND php_rand()
static int php_crypt_rand_seeded=0;
PHP_MINIT_FUNCTION(crypt)
{
REGISTER_LONG_CONSTANT("CRYPT_SALT_LENGTH", PHP_MAX_SALT_LEN, CONST_CS | CONST_PERSISTENT);
@ -101,6 +103,16 @@ PHP_MINIT_FUNCTION(crypt)
}
PHP_RINIT_FUNCTION(crypt)
{
if(!php_crypt_rand_seeded) {
php_srand(time(0) * getpid() * (php_combined_lcg(TSRMLS_C) * 10000.0));
php_crypt_rand_seeded=1;
}
return SUCCESS;
}
static unsigned char itoa64[] = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static void php_to64(char *s, long v, int n) {

7
ext/standard/lcg.c
View File

@ -42,11 +42,6 @@ static int php_lcg_initialized = 0;
* The function combines two CGs with periods of
* 2^31 - 85 and 2^31 - 249. The period of this function
* is equal to the product of both primes.
*
* There are only about 65k distinct starting values, that's
* not much... If PHP is running as CGI, randomness is quite bad.
* If it is run as a module, it's long-livin', so no problem in that
* case.
*/
#define MODMULT(a, b, c, m, s) q = s/a;s=b*(s-a*q)-c*q;if(s<0)s+=m
@ -108,5 +103,5 @@ PHP_FUNCTION(lcg_value)
* c-basic-offset: 4
* End:
* vim600: sw=4 ts=4 tw=78 fdm=marker
* vim<600: sw=8 ts=8 tw=78
* vim<600: sw=4 ts=4 tw=78
*/

1
ext/standard/php_crypt.h
View File

@ -26,6 +26,7 @@
PHP_FUNCTION(crypt);
#if HAVE_CRYPT
PHP_MINIT_FUNCTION(crypt);
PHP_RINIT_FUNCTION(crypt);
#endif
#endif

6
ext/standard/php_math.h
View File

@ -34,6 +34,12 @@ PHP_FUNCTION(log);
PHP_FUNCTION(log10);
PHP_FUNCTION(pow);
PHP_FUNCTION(sqrt);
PHP_FUNCTION(srand);
PHP_FUNCTION(rand);
PHP_FUNCTION(getrandmax);
PHP_FUNCTION(mt_srand);
PHP_FUNCTION(mt_rand);
PHP_FUNCTION(mt_getrandmax);
PHP_FUNCTION(abs);
PHP_FUNCTION(ceil);
PHP_FUNCTION(floor);

111
ext/standard/php_rand.h
View File

@ -15,102 +15,47 @@
| Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
| Zeev Suraski <zeev@zend.com> |
| Pedro Melo <melo@ip.pt> |
| Jeroen van Wolffelaar <jeroen@php.net> |
| |
| Based on code from: Shawn Cokus <Cokus@math.washington.edu> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
/* Layout implementation random functions
*
* The PHPAPI contains these functions:
* - long php_rand()
* - long php_rand_range(long min, long max)
* - void php_srand()
* - long php_getrandmax()
*
* Note that it is not possible to choose the algoritm. This is done to
* give the user the possibility to control all randomness by means of
* srand()/php.ini in a portable and consistent way.
*
*
* --Jeroen
*/
/* TODO:
* - make constants available to PHP-user
* - MINFO section about which random number generators are available
* - Nuke randmax by enhancing PHP_RAND_RANGE to work well in the case of a
* greater request than the real (internal) randmax is
* - Implement LCG
* - Implement a real-random source? (via internet, and/or /dev/urandom?)
* - Can lrand48 be thread-safe?
* - Is random() useful sometimes?
* - Which system algorithms are available, maybe name them after real
* algorithm by compile-time detection?
* - Get this to compile :-)
*/
#ifndef PHP_RAND_H
#define PHP_RAND_H
#include <stdlib.h>
/* FIXME: that '_php_randgen_entry' needed, or not? */
typedef struct _php_randgen_entry {
void (*srand)(long seed TSRMLS_DC);
long (*rand)(TSRMLS_D);
long randmax;
char *ini_str;
} php_randgen_entry;
#ifndef RAND_MAX
#define RAND_MAX (1<<15)
#endif
/* an ARRAY of POINTERS, not vice versa */
extern php_randgen_entry *php_randgen_entries[];
#if HAVE_LRAND48
#define PHP_RAND_MAX 2147483647
#else
#define PHP_RAND_MAX RAND_MAX
#endif
#define PHP_RANDGEN_ENTRY(which, nsrand, nrand, nrandmax, nini_str) { \
php_randgen_entries[which] = emalloc(sizeof(php_randgen_entry)); \
php_randgen_entries[which]->srand = nsrand; \
php_randgen_entries[which]->rand = nrand; \
php_randgen_entries[which]->randmax = nrandmax; \
php_randgen_entries[which]->ini_str = nini_str; \
}
/* Define rand Function wrapper */
#ifdef HAVE_RANDOM
#define php_rand() random()
#else
#ifdef HAVE_LRAND48
#define php_rand() lrand48()
#else
#define php_rand() rand()
#endif
#endif
/* Define random generator constants */
#define PHP_RAND_SYS 0
#define PHP_RAND_LRAND48 1
#define PHP_RAND_MT 2
#define PHP_RAND_LCG 3
#define PHP_RAND_DEFAULT PHP_RAND_MT
/* how many there are */
#define PHP_RAND_NUMRANDS 4
/* Proto's */
PHP_RINIT_FUNCTION(rand);
PHP_MINIT_FUNCTION(rand);
PHP_MINIT_FUNCTION(rand_mt);
PHP_MINIT_FUNCTION(rand_sys);
PHP_FUNCTION(srand);
PHP_FUNCTION(rand);
PHP_FUNCTION(getrandmax);
PHP_FUNCTION(mt_srand);
PHP_FUNCTION(mt_rand);
PHP_FUNCTION(mt_getrandmax);
PHPAPI long php_rand(TSRMLS_D);
PHPAPI long php_rand_range(long min, long max TSRMLS_DC);
PHPAPI double php_drand(TSRMLS_D);
PHPAPI long php_randmax(TSRMLS_D);
/* Define srand Function wrapper */
#ifdef HAVE_SRANDOM
#define php_srand(seed) srandom((unsigned int)seed)
#else
#ifdef HAVE_SRAND48
#define php_srand(seed) srand48((long)seed)
#else
#define php_srand(seed) srand((unsigned int)seed)
#endif
#endif
#endif /* PHP_RAND_H */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: fdm=marker
* vim: sw=4 ts=4 tw=78
*/

1
ext/standard/php_standard.h
View File

@ -20,7 +20,6 @@
#include "basic_functions.h"
#include "php_math.h"
#include "php_rand.h"
#include "php_string.h"
#include "base64.h"
#include "php_dir.h"

505
ext/standard/rand.c
View File

@ -15,7 +15,8 @@
| Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
| Zeev Suraski <zeev@zend.com> |
| Pedro Melo <melo@ip.pt> |
| Jeroen van Wolffelaar <jeroen@php.net> |
| |
| Based on code from: Shawn Cokus <Cokus@math.washington.edu> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
@ -25,266 +26,302 @@
#include "php.h"
#include "php_math.h"
#include "php_rand.h"
#include "php_lcg.h"
#include "php_ini.h"
#include "zend_execute.h"
#include "basic_functions.h"
/* See php_rand.h for information about layout */
/*
This is the ``Mersenne Twister'' random number generator MT19937, which
generates pseudorandom integers uniformly distributed in 0..(2^32 - 1)
starting from any odd seed in 0..(2^32 - 1). This version is a recode
by Shawn Cokus (Cokus@math.washington.edu) on March 8, 1998 of a version by
Takuji Nishimura (who had suggestions from Topher Cooper and Marc Rieffel in
July-August 1997).
Effectiveness of the recoding (on Goedel2.math.washington.edu, a DEC Alpha
running OSF/1) using GCC -O3 as a compiler: before recoding: 51.6 sec. to
generate 300 million random numbers; after recoding: 24.0 sec. for the same
(i.e., 46.5% of original time), so speed is now about 12.5 million random
number generations per second on this machine.
According to the URL <http://www.math.keio.ac.jp/~matumoto/emt.html>
(and paraphrasing a bit in places), the Mersenne Twister is ``designed
with consideration of the flaws of various existing generators,'' has
a period of 2^19937 - 1, gives a sequence that is 623-dimensionally
equidistributed, and ``has passed many stringent tests, including the
die-hard test of G. Marsaglia and the load test of P. Hellekalek and
S. Wegenkittl.'' It is efficient in memory usage (typically using 2506
to 5012 bytes of static data, depending on data type sizes, and the code
is quite short as well). It generates random numbers in batches of 624
at a time, so the caching and pipelining of modern systems is exploited.
It is also divide- and mod-free.
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public License as published by
the Free Software Foundation (either version 2 of the License or, at your
option, any later version). This library is distributed in the hope that
it will be useful, but WITHOUT ANY WARRANTY, without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
the GNU Library General Public License for more details. You should have
received a copy of the GNU Library General Public License along with this
library; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307, USA.
The code as Shawn received it included the following notice:
Copyright (C) 1997 Makoto Matsumoto and Takuji Nishimura. When
you use this, send an e-mail to <matumoto@math.keio.ac.jp> with
an appropriate reference to your work.
It would be nice to CC: <Cokus@math.washington.edu> when you write.
/* an ARRAY of POINTERS, not vice versa */
php_randgen_entry *php_randgen_entries[PHP_RAND_NUMRANDS];
php_uint32 must be an unsigned integer type capable of holding at least 32
bits; exactly 32 should be fastest, but 64 is better on an Alpha with
GCC at -O3 optimization so try your options and see what's best for you
#define PHP_HAS_SRAND(which) (php_randgen_entries[which] && php_randgen_entries[which]->srand)
#define PHP_SRAND(which,seed) ((*(php_randgen_entries[which]->srand))(seed TSRMLS_CC))
#define PHP_RAND(which) ((*(php_randgen_entries[which]->rand))(TSRMLS_C))
#define PHP_RANDMAX(which) (php_randgen_entries[which]->randmax)
#define PHP_RAND_INISTR(which) (php_randgen_entries[which]->ini_str)
Melo: we should put some ifdefs here to catch those alphas...
*/
#define CURR_GEN BG(rand_generator_current)
PHP_MINIT_FUNCTION(rand)
{
PHP_MINIT(rand_sys)(INIT_FUNC_ARGS_PASSTHRU);
PHP_MINIT(rand_mt)(INIT_FUNC_ARGS_PASSTHRU);
/* lcg not yet implemented */
php_randgen_entries[PHP_RAND_LCG] = NULL;
#define N MT_N /* length of state vector */
#define M (397) /* a period parameter */
#define K (0x9908B0DFU) /* a magic constant */
#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 */
return SUCCESS;
}
#define MT_RAND_MAX ((long)(0x7FFFFFFF)) /* (1<<31) - 1 */
/* TODO: check that this function is called on the start of each script
* execution: not more often, not less often.
*
* Note that system rand is inherently thread-unsafe: A different thread can
* always eat up some rand()'s, and thus nuking your expected sequence.
* Another reason to use MT...
/* {{{ seedMT
*/
PHP_RINIT_FUNCTION(rand)
static void seedMT(php_uint32 seed TSRMLS_DC)
{
register int i;
/*
We initialize state[0..(N-1)] via the generator
x_new = (69069 * x_old) mod 2^32
from Line 15 of Table 1, p. 106, Sec. 3.3.4 of Knuth's
_The Art of Computer Programming_, Volume 2, 3rd ed.
Notes (SJC): I do not know what the initial state requirements
of the Mersenne Twister are, but it seems this seeding generator
could be better. It achieves the maximum period for its modulus
(2^30) iff x_initial is odd (p. 20-21, Sec. 3.2.1.2, Knuth); if
x_initial can be even, you have sequences like 0, 0, 0, ...;
2^31, 2^31, 2^31, ...; 2^30, 2^30, 2^30, ...; 2^29, 2^29 + 2^31,
2^29, 2^29 + 2^31, ..., etc. so I force seed to be odd below.
Even if x_initial is odd, if x_initial is 1 mod 4 then
the lowest bit of x is always 1,
the next-to-lowest bit of x is always 0,
the 2nd-from-lowest bit of x alternates ... 0 1 0 1 0 1 0 1 ... ,
the 3rd-from-lowest bit of x 4-cycles ... 0 1 1 0 0 1 1 0 ... ,
the 4th-from-lowest bit of x has the 8-cycle ... 0 0 0 1 1 1 1 0 ... ,
...
and if x_initial is 3 mod 4 then
the lowest bit of x is always 1,
the next-to-lowest bit of x is always 1,
the 2nd-from-lowest bit of x alternates ... 0 1 0 1 0 1 0 1 ... ,
the 3rd-from-lowest bit of x 4-cycles ... 0 0 1 1 0 0 1 1 ... ,
the 4th-from-lowest bit of x has the 8-cycle ... 0 0 1 1 1 1 0 0 ... ,
...
The generator's potency (min. s>=0 with (69069-1)^s = 0 mod 2^32) is
16, which seems to be alright by p. 25, Sec. 3.2.1.3 of Knuth. It
also does well in the dimension 2..5 spectral tests, but it could be
better in dimension 6 (Line 15, Table 1, p. 106, Sec. 3.3.4, Knuth).
Note that the random number user does not see the values generated
here directly since reloadMT() will always munge them first, so maybe
none of all of this matters. In fact, the seed values made here could
even be extra-special desirable if the Mersenne Twister theory says
so-- that's why the only change I made is to restrict to odd seeds.
*/
/* seed all number-generators */
/* FIXME: or seed relevant numgen on init/update ini-entry? */
for (i = 0 ; i < PHP_RAND_NUMRANDS ; i++) {
if (PHP_HAS_SRAND(i)) {
#define SRAND_A_RANDOM_SEED ((long)time(0) * (long)getpid() * (long)(php_combined_lcg(TSRMLS_C) * 10000.0)) /* something with microtime? */
PHP_SRAND(i,SRAND_A_RANDOM_SEED);
}
}
register php_uint32 x = (seed | 1U) & 0xFFFFFFFFU, *s = BG(state);
register int j;
return SUCCESS;
for(BG(left)=0, *s++=x, j=N; --j;
*s++ = (x*=69069U) & 0xFFFFFFFFU);
}
/* }}} */
static php_uint32 reloadMT(TSRMLS_D)
{
register php_uint32 *p0=BG(state), *p2=BG(state)+2, *pM=BG(state)+M, s0, s1;
register int j;
if(BG(left) < -1)
seedMT(4357U TSRMLS_CC);
BG(left)=N-1, BG(next)=BG(state)+1;
for(s0=BG(state)[0], s1=BG(state)[1], j=N-M+1; --j; s0=s1, s1=*p2++)
*p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
for(pM=BG(state), j=M; --j; s0=s1, s1=*p2++)
*p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
s1=BG(state)[0], *p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
s1 ^= (s1 >> 11);
s1 ^= (s1 << 7) & 0x9D2C5680U;
s1 ^= (s1 << 15) & 0xEFC60000U;
return(s1 ^ (s1 >> 18));
}
/* INI */
static int randgen_str_to_int(char *str, int strlen)
{
register int i;
for (i = 0 ; i < PHP_RAND_NUMRANDS ; i++) {
if (!strcasecmp(str, PHP_RAND_INISTR(i)))
return i;
}
return -1;
static inline php_uint32 randomMT(void)
{
php_uint32 y;
TSRMLS_FETCH();
if(--BG(left) < 0)
return(reloadMT(TSRMLS_C));
y = *BG(next)++;
y ^= (y >> 11);
y ^= (y << 7) & 0x9D2C5680U;
y ^= (y << 15) & 0xEFC60000U;
return(y ^ (y >> 18));
}
/* {{{ proto void srand(int seed)
Seeds random number generator */
PHP_FUNCTION(srand)
{
pval **arg;
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_long_ex(arg);
php_srand((*arg)->value.lval);
}
/* }}} */
/* {{{ proto void mt_srand(int seed)
Seeds Mersenne Twister random number generator */
PHP_FUNCTION(mt_srand)
{
pval **arg;
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &arg) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_long_ex(arg);
seedMT((*arg)->value.lval TSRMLS_CC);
}
/* }}} */
/* {{{ proto int rand([int min, int max])
Returns a random number */
PHP_FUNCTION(rand)
{
pval **p_min=NULL, **p_max=NULL;
/* FIXME: check that this is called on initial ini-parsing too */
/* FIXME: what if no ini-entry was present? */
static PHP_INI_MH(OnUpdateRandGen)
{
/* Set BG(rand_generator) to the correct integer value indicating
* ini-setting */
BG(rand_generator) = randgen_str_to_int(new_value, new_value_length);
if (BG(rand_generator) == -1) {
/* FIXME: is this possible? What happens if this occurs during
* ini-parsing at startup? */
php_error(E_WARNING,"Invalid value for random_number_generator: \"%s\"", new_value);
/* Fallback: */
BG(rand_generator) = PHP_RAND_DEFAULT;
switch (ZEND_NUM_ARGS()) {
case 0:
break;
case 2:
if (zend_get_parameters_ex(2, &p_min, &p_max)==FAILURE) {
RETURN_FALSE;
}
convert_to_long_ex(p_min);
convert_to_long_ex(p_max);
if ((*p_max)->value.lval-(*p_min)->value.lval < 0) {
php_error(E_WARNING, "rand(): Invalid range: %ld..%ld", (*p_min)->value.lval, (*p_max)->value.lval);
} else if ((*p_max)->value.lval-(*p_min)->value.lval > PHP_RAND_MAX){
php3_error(E_WARNING, "rand(): Invalid range: %ld..%ld", (*p_min)->value.lval, (*p_max)->value.lval);
}
break;
default:
WRONG_PARAM_COUNT;
break;
}
#ifdef DEBUG_RAND
printf("\nRAND-INI updated: %d\n",BG(rand_generator));
#endif
return SUCCESS;
}
return_value->type = IS_LONG;
PHP_INI_BEGIN()
/* FIXME: default is hardcoded here, this is the second place */
PHP_INI_ENTRY("random_number_generator", "mt", PHP_INI_ALL, OnUpdateRandGen)
PHP_INI_END()
return_value->value.lval = php_rand();
/* srand */
/* FIXME: isn't used? */
/* {{{ void php_srand(void) */
static void php_srand(TSRMLS_D)
{
CURR_GEN = BG(rand_generator);
PHP_SRAND(BG(rand_generator), SRAND_A_RANDOM_SEED);
}
/* }}} */
/* {{{ [mt_]srand common */
#define pim_srand_common(name,type) \
PHP_FUNCTION(name) \
{ \
zval **seed; \
zval **alg; \
\
switch (ZEND_NUM_ARGS()) { \
case 0: \
CURR_GEN = BG(rand_generator); \
PHP_SRAND(BG(rand_generator), SRAND_A_RANDOM_SEED); \
RETURN_TRUE; \
case 1: \
zend_get_parameters_ex(1, &seed); \
convert_to_long_ex(seed); \
CURR_GEN = type; \
PHP_SRAND(type, Z_LVAL_PP(seed)); \
RETURN_TRUE; \
case 2: \
/* algorithm, seed is most logic, though it is the other way
* around than current way... */ \
zend_get_parameters_ex(2, &alg, &seed); \
convert_to_long_ex(seed); \
convert_to_long_ex(alg); \
if (0 > Z_LVAL_PP(alg) || Z_LVAL_PP(alg) >= PHP_RAND_NUMRANDS) { \
php_error(E_WARNING, "%s(): There is no algorithm %d.", get_active_function_name(TSRMLS_C), Z_LVAL_PP(alg)); \
RETURN_FALSE; \
} \
if (!PHP_HAS_SRAND(Z_LVAL_PP(alg))) { \
php_error(E_WARNING, "%s(): Algorithm %d does not support reproducable results.", get_active_function_name(TSRMLS_C), Z_LVAL_PP(alg)); \
RETURN_FALSE; \
} \
CURR_GEN = Z_LVAL_PP(alg); \
PHP_SRAND(Z_LVAL_PP(alg), Z_LVAL_PP(seed)); \
RETURN_TRUE; \
default: \
WRONG_PARAM_COUNT; \
} \
}
/* }}} */
/* {{{ proto bool srand(int seed)
Seeds random number generator */
pim_srand_common(srand,PHP_RAND_SYS)
/* }}} */
/* {{{ proto bool mt_srand(int seed)
Seeds random number generator */
pim_srand_common(mt_srand,PHP_RAND_MT)
/* }}} */
/* rand */
/* {{{ PHPAPI long php_rand(void) */
PHPAPI long php_rand(TSRMLS_D)
{
return PHP_RAND(CURR_GEN);
}
/* }}} */
/* {{{ PHPAPI double php_drand(void)
* returns a double in the range [0,1) */
PHPAPI double php_drand(TSRMLS_D)
{
return (double)php_rand(TSRMLS_C) /
(double)(PHP_RANDMAX(CURR_GEN)+1.0);
}
/* }}} */
/* {{{ macro: PHP_RAND_RANGE */
#define PHP_RAND_RANGE(which,min,max,result) { \
/*
* 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
* Expressed in real numbers, this becomes:
*
* [0,M+1[ mapped to [a,b+1[
*
* Let n = the random number and n' = the mapped random number
* So the formula needs to be:
*
* n' = a + n((b+1)-a)/(m+1)
*
* This isn't perfect, because n only takes integer values. So when a..b
* spans a significant portion of 0..M, some numbers have nearly twice as
* much chance. But since twice a very small chance is still a very small
* chance, it's ignored.
*
* --Rasmus and Jeroen
*/ \
(result) = PHP_RAND(which); \
if ((max) < (min)) { \
php_error(E_WARNING, "%s(): Invalid range: %ld..%ld (minimum can't be larger than maximum)", \
get_active_function_name(TSRMLS_C), (min), (max)); \
} else if ( (max) - (min) > PHP_RANDMAX(which) ) { \
/* TODO: this can done better, get two numbers and combine... */ \
php_error(E_WARNING, "%s(): Invalid range: %ld..%ld (can't give that much randomness)", \
get_active_function_name(TSRMLS_C), (min), (max)); \
} \
(result) = (min) + (long) ((double)((max)-(min)+1) * (result)/(PHP_RANDMAX(which)+1.0)); \
* 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
# artifically and using:
#
# 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:
#
# n' = a + n(b-a+1)/(M+1)
*
* -RL
*/
if (p_min && p_max) { /* implement range */
return_value->value.lval = (*p_min)->value.lval +
(int)((double)((*p_max)->value.lval - (*p_min)->value.lval + 1.0) * return_value->value.lval/(PHP_RAND_MAX+1.0));
}
}
/* }}} */
/* {{{ PHPAPI long php_rand_range(long min, long max) */
PHPAPI long php_rand_range(long min, long max TSRMLS_DC)
/* {{{ proto int mt_rand([int min, int max])
Returns a random number from Mersenne Twister */
PHP_FUNCTION(mt_rand)
{
register long result;
pval **p_min=NULL, **p_max=NULL;
switch (ZEND_NUM_ARGS()) {
case 0:
break;
case 2:
if (zend_get_parameters_ex(2, &p_min, &p_max)==FAILURE) {
RETURN_FALSE;
}
convert_to_long_ex(p_min);
convert_to_long_ex(p_max);
if ((*p_max)->value.lval-(*p_min)->value.lval <= 0) {
php_error(E_WARNING, "mt_rand(): Invalid range: %ld..%ld", (*p_min)->value.lval, (*p_max)->value.lval);
}else if ((*p_max)->value.lval-(*p_min)->value.lval > MT_RAND_MAX){
php3_error(E_WARNING, "mt_rand(): Invalid range: %ld..%ld", (*p_min)->value.lval, (*p_max)->value.lval);
}
break;
default:
WRONG_PARAM_COUNT;
break;
}
return_value->type = IS_LONG;
/*
* 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*
* better than clearing the msb.
* Update:
* I talked with Cokus via email and it won't ruin the algorithm
*/
return_value->value.lval = (long)(randomMT() >> 1);
PHP_RAND_RANGE(CURR_GEN, min, max, result);
return result;
}
/* }}} */
/* {{{ [mt_]rand common */
#define PHP_FUNCTION_RAND(name,which) \
PHP_FUNCTION(name) \
{ \
zval **min, **max; \
\
switch (ZEND_NUM_ARGS()) { \
case 0: \
RETURN_LONG(PHP_RAND(which)); \
case 2: \
if (zend_get_parameters_ex(2, &min, &max)==FAILURE) { \
RETURN_FALSE; \
} \
convert_to_long_ex(min); \
convert_to_long_ex(max); \
Z_TYPE_P(return_value) = IS_LONG; \
PHP_RAND_RANGE(which, Z_LVAL_PP(min), \
Z_LVAL_PP(max), Z_LVAL_P(return_value)); \
return; \
default: \
WRONG_PARAM_COUNT; \
break; \
} \
}
/* }}} */
/* {{{ proto int rand([int min, int max])
Returns a random number */
PHP_FUNCTION_RAND(rand,PHP_RAND_SYS)
/* }}} */
/* {{{ proto int mt_rand([int min, int max])
Returns a random number by means of Mersenne Twister */
PHP_FUNCTION_RAND(mt_rand,PHP_RAND_MT)
/* }}} */
/* getrandmax */
/* {{{ PHPAPI long php_randmax(void)
Returns the maximum value a random number can have */
PHPAPI long php_randmax(TSRMLS_D)
{
return PHP_RANDMAX(CURR_GEN);
if (p_min && p_max) { /* implement range */
return_value->value.lval = (*p_min)->value.lval +
(long)((double)((*p_max)->value.lval - (*p_min)->value.lval + 1.0) * return_value->value.lval/(MT_RAND_MAX+1.0));
}
}
/* }}} */
@ -296,19 +333,25 @@ PHP_FUNCTION(getrandmax)
WRONG_PARAM_COUNT;
}
RETURN_LONG( php_randmax(TSRMLS_C));
return_value->type = IS_LONG;
return_value->value.lval = PHP_RAND_MAX;
}
/* }}} */
/* {{{ proto int mt_getrandmax(void)
Returns the maximum value a random number can have */
Returns the maximum value a random number from Mersenne Twister can have */
PHP_FUNCTION(mt_getrandmax)
{
if (ZEND_NUM_ARGS() != 0) {
WRONG_PARAM_COUNT;
}
RETURN_LONG( php_randmax(TSRMLS_C) );
return_value->type = IS_LONG;
/*
* Melo: it could be 2^^32 but we only use 2^^31 to maintain
* compatibility with the previous php_rand
*/
return_value->value.lval = MT_RAND_MAX; /* 2^^31 */
}
/* }}} */
@ -318,5 +361,5 @@ PHP_FUNCTION(mt_getrandmax)
* c-basic-offset: 4
* End:
* vim600: sw=4 ts=4 tw=78 fdm=marker
* vim: sw=4 ts=4 tw=78
* vim<600: sw=4 ts=4 tw=78
*/

234
ext/standard/rand_mt.c
View File

@ -1,234 +0,0 @@
/*
+----------------------------------------------------------------------+
| PHP version 4.0 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2001 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 2.02 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available at through the world-wide-web at |
| http://www.php.net/license/2_02.txt. |
| 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. |
+----------------------------------------------------------------------+
| Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
| Zeev Suraski <zeev@zend.com> |
| Pedro Melo <melo@ip.pt> |
| Jeroen van Wolffelaar <jeroen@php.net> |
| |
| Based on code from: Shawn Cokus <Cokus@math.washington.edu> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#include <stdlib.h>
#include "php.h"
#include "php_rand.h"
#include "basic_functions.h"
/*
This is the ``Mersenne Twister'' random number generator MT19937, which
generates pseudorandom integers uniformly distributed in 0..(2^32 - 1)
starting from any odd seed in 0..(2^32 - 1). This version is a recode
by Shawn Cokus (Cokus@math.washington.edu) on March 8, 1998 of a version by
Takuji Nishimura (who had suggestions from Topher Cooper and Marc Rieffel in
July-August 1997).
Effectiveness of the recoding (on Goedel2.math.washington.edu, a DEC Alpha
running OSF/1) using GCC -O3 as a compiler: before recoding: 51.6 sec. to
generate 300 million random numbers; after recoding: 24.0 sec. for the same
(i.e., 46.5% of original time), so speed is now about 12.5 million random
number generations per second on this machine.
According to the URL <http://www.math.keio.ac.jp/~matumoto/emt.html>
(and paraphrasing a bit in places), the Mersenne Twister is ``designed
with consideration of the flaws of various existing generators,'' has
a period of 2^19937 - 1, gives a sequence that is 623-dimensionally
equidistributed, and ``has passed many stringent tests, including the
die-hard test of G. Marsaglia and the load test of P. Hellekalek and
S. Wegenkittl.'' It is efficient in memory usage (typically using 2506
to 5012 bytes of static data, depending on data type sizes, and the code
is quite short as well). It generates random numbers in batches of 624
at a time, so the caching and pipelining of modern systems is exploited.
It is also divide- and mod-free.
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public License as published by
the Free Software Foundation (either version 2 of the License or, at your
option, any later version). This library is distributed in the hope that
it will be useful, but WITHOUT ANY WARRANTY, without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
the GNU Library General Public License for more details. You should have
received a copy of the GNU Library General Public License along with this
library; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307, USA.
The code as Shawn received it included the following notice:
Copyright (C) 1997 Makoto Matsumoto and Takuji Nishimura. When
you use this, send an e-mail to <matumoto@math.keio.ac.jp> with
an appropriate reference to your work.
It would be nice to CC: <Cokus@math.washington.edu> when you write.
php_uint32 must be an unsigned integer type capable of holding at least 32
bits; exactly 32 should be fastest, but 64 is better on an Alpha with
GCC at -O3 optimization so try your options and see what's best for you
Melo: we should put some ifdefs here to catch those alphas...
*/
static void _php_srand_mt(long seed TSRMLS_DC);
static inline long _php_rand_mt_reload(TSRMLS_D);
static long _php_rand_mt(TSRMLS_D);
/*
* Melo: it could be 2^^32 but we only use 2^^31 to maintain
* compatibility with the previous php_rand
*/
#define PHP_RANDMAX_MT ((long)(0x7FFFFFFF)) /* 2^^31 - 1 */
PHP_MINIT_FUNCTION(rand_mt)
{
PHP_RANDGEN_ENTRY(PHP_RAND_MT,
_php_srand_mt, /* void srand(long seed) */
_php_rand_mt, /* long rand(void) */
PHP_RANDMAX_MT, /* long randmax */
"mt" /* char *ini_str */
);
return SUCCESS;
}
#define N MT_N /* length of state vector */
#define M (397) /* a period parameter */
#define K (0x9908B0DFU) /* a magic constant */
#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 */
#define MIX_AND_RETURN(var) { \
(var) ^= ((var) >> 11); \
(var) ^= ((var) << 7) & 0x9D2C5680U; \
(var) ^= ((var) << 15) & 0xEFC60000U; \
(var) ^= ((var) >> 18); \
/*
* Melo: hmms.. these are 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*
* better than clearing the msb.
* Update:
* I talked with Cokus via email and it won't ruin the algorithm
*
* Jeroen: moved this to end of php_rand_mt and php_rand_mt_reload
*/ \
return (long)((var) >> 1); \
}
/* {{{ void _php_srand_mt(long seed)
*/
static void _php_srand_mt(long seed TSRMLS_DC)
{
/*
We initialize state[0..(N-1)] via the generator
x_new = (69069 * x_old) mod 2^32
from Line 15 of Table 1, p. 106, Sec. 3.3.4 of Knuth's
_The Art of Computer Programming_, Volume 2, 3rd ed.
Notes (SJC): I do not know what the initial state requirements
of the Mersenne Twister are, but it seems this seeding generator
could be better. It achieves the maximum period for its modulus
(2^30) iff x_initial is odd (p. 20-21, Sec. 3.2.1.2, Knuth); if
x_initial can be even, you have sequences like 0, 0, 0, ...;
2^31, 2^31, 2^31, ...; 2^30, 2^30, 2^30, ...; 2^29, 2^29 + 2^31,
2^29, 2^29 + 2^31, ..., etc. so I force seed to be odd below.
Even if x_initial is odd, if x_initial is 1 mod 4 then
the lowest bit of x is always 1,
the next-to-lowest bit of x is always 0,
the 2nd-from-lowest bit of x alternates ... 0 1 0 1 0 1 0 1 ... ,
the 3rd-from-lowest bit of x 4-cycles ... 0 1 1 0 0 1 1 0 ... ,
the 4th-from-lowest bit of x has the 8-cycle ... 0 0 0 1 1 1 1 0 ... ,
...
and if x_initial is 3 mod 4 then
the lowest bit of x is always 1,
the next-to-lowest bit of x is always 1,
the 2nd-from-lowest bit of x alternates ... 0 1 0 1 0 1 0 1 ... ,
the 3rd-from-lowest bit of x 4-cycles ... 0 0 1 1 0 0 1 1 ... ,
the 4th-from-lowest bit of x has the 8-cycle ... 0 0 1 1 1 1 0 0 ... ,
...
The generator's potency (min. s>=0 with (69069-1)^s = 0 mod 2^32) is
16, which seems to be alright by p. 25, Sec. 3.2.1.3 of Knuth. It
also does well in the dimension 2..5 spectral tests, but it could be
better in dimension 6 (Line 15, Table 1, p. 106, Sec. 3.3.4, Knuth).
Note that the random number user does not see the values generated
here directly since reloadMT() will always munge them first, so maybe
none of all of this matters. In fact, the seed values made here could
even be extra-special desirable if the Mersenne Twister theory says
so-- that's why the only change I made is to restrict to odd seeds.
*/
register php_uint32 x = ((php_uint32)seed | 1U) & 0xFFFFFFFFU, *s = BG(state);
register int j;
for(BG(left)=0, *s++=x, j=N; --j;
*s++ = (x*=69069U) & 0xFFFFFFFFU);
}
/* }}} */
/* {{{ long _php_rand_mt_reload(void) [internal function]
* Generates a new batch of random numbers, and returns the first of it */
static inline long _php_rand_mt_reload(TSRMLS_D)
{
register php_uint32 *p0=BG(state), *p2=BG(state)+2, *pM=BG(state)+M, s0, s1;
register int j;
if(BG(left) < -1)
_php_srand_mt(4357U TSRMLS_CC);
BG(left)=N-1, BG(next)=BG(state)+1;
for(s0=BG(state)[0], s1=BG(state)[1], j=N-M+1; --j; s0=s1, s1=*p2++)
*p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
for(pM=BG(state), j=M; --j; s0=s1, s1=*p2++)
*p0++ = *pM++ ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
s1=BG(state)[0], *p0 = *pM ^ (mixBits(s0, s1) >> 1) ^ (loBit(s1) ? K : 0U);
MIX_AND_RETURN(s1);
}
/*}}}*/
/* {{{ long _php_rand_mt(void) */
static long _php_rand_mt(TSRMLS_D)
{
php_uint32 y;
if(--BG(left) < 0)
return(_php_rand_mt_reload(TSRMLS_C));
y = *BG(next)++;
MIX_AND_RETURN(y);
}
/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: sw=4 ts=4 tw=78 fdm=marker
* vim<600: sw=4 ts=4 tw=78
*/

78
ext/standard/rand_sys.c
View File

@ -1,78 +0,0 @@
/*
+----------------------------------------------------------------------+
| PHP version 4.0 |
+----------------------------------------------------------------------+
| Copyright (c) 1997-2001 The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 2.02 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available at through the world-wide-web at |
| http://www.php.net/license/2_02.txt. |
| 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. |
+----------------------------------------------------------------------+
| Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
| Zeev Suraski <zeev@zend.com> |
| Jeroen van Wolffelaar <jeroen@php.net> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
#include <stdlib.h>
#include "php_reentrancy.h"
#include "php_rand.h"
#include "basic_functions.h"
/* rand() & co (thread safe this time!): */
static void _php_srand_sys(long seed TSRMLS_DC)
{
BG(rand_sys_seed) = (unsigned int) seed;
}
static long _php_rand_sys(TSRMLS_D)
{
return (long) php_rand_r(&BG(rand_sys_seed));
}
PHP_MINIT_FUNCTION(rand_sys)
{
#ifndef RAND_MAX
#define RAND_MAX (1<<15)
#endif
PHP_RANDGEN_ENTRY(PHP_RAND_SYS,
_php_srand_sys, /* void srand(long seed) */
_php_rand_sys, /* long rand(void) */
(long)RAND_MAX, /* long randmax */
"system" /* char *ini_str */
);
/* random() is left away, no manual page on my system, no bigger range than
* rand()
* --jeroen
*/
/* lrand48 (_not_ TS) */
#if HAVE_LRAND48
PHP_RANDGEN_ENTRY(PHP_RAND_LRAND48,
srand48, /* void srand(long seed) */
lrand48, /* long rand(void) */
2147483647L, /* long randmax */
"lrand48" /* char *ini_str */
);
#else
php_randgen_entries[PHP_RAND_LRAND48] = NULL;
#endif
return SUCCESS;
}
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: sw=4 ts=4 tw=78 fdm=marker
* vim: sw=4 ts=4 tw=78
*/