drand48.c revision ab073b324433ebc8947d28ade932d29d0e809795
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1988 AT&T */
/* All Rights Reserved */
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* drand48, etc. pseudo-random number generator
* This implementation assumes unsigned short integers of at least
* 16 bits, long integers of at least 32 bits, and ignores
* overflows on adding or multiplying two unsigned integers.
* Two's-complement representation is assumed in a few places.
* Some extra masking is done if unsigneds are exactly 16 bits
* or longs are exactly 32 bits, but so what?
* An assembly-language implementation would run significantly faster.
*/
/*
* New assumptions (supercede those stated above) for 64-bit work.
* Longs are now 64 bits, and we are bound by standards to return
* type long, hovever all internal calculations where long was
* previously used (32 bit precision) are now using the int32_t
* type (32 bit precision in both ILP32 and LP64 worlds).
*/
static int init48done = 0;
mutex_enter(&seed_lock); \
mutex_exit(&seed_lock); \
return (res); }
mutex_enter(&seed_lock); \
mutex_exit(&seed_lock); \
return (res); }
#define N 16
#define X0 0x330E
#define X1 0xABCD
#define X2 0x1234
#define A0 0xE66D
#define A1 0xDEEC
#define A2 0x5
#define C 0xB
return (v)
v = F(); REST(v); }
/* Way ugly solution to problem names, but it works */
#define x _drand48_x
#define a _drand48_a
#define c _drand48_c
/* End way ugly */
static unsigned short lastx[3];
static void next(void);
static double
ipf_r_drand48_u(void)
{
next();
}
static long
ipf_r_lrand48_u(void)
{
next();
}
static void
init48(void)
{
init48done = 1;
}
static long
ipf_r_mrand48_u(void)
{
next();
}
static void
next(void)
{
MUL(a[0], x[0], p);
MUL(a[0], x[1], q);
MUL(a[1], x[0], r);
a[0] * x[2] + a[1] * x[1] + a[2] * x[0]);
x[0] = LOW(p[0]);
}
void
ipf_r_srand48(long seedval)
{
if (init48done == 0)
init48();
}
unsigned short *
{
if (init48done == 0)
init48();
return (lastx);
}
void
{
if (init48done == 0)
init48();
}
#ifdef DRIVER
/*
This should print the sequences of integers in Tables 2
and 1 of the TM:
1623, 3442, 1447, 1829, 1305, ...
657EB7255101, D72A0C966378, 5A743C062A23, ...
*/
#include <stdio.h>
main()
{
int i;
for (i = 0; i < 80; i++) {
}
}
#else
unsigned
{
static int seeded = 0;
if (seeded == 0) {
long seed;
/*
* Keep reseeding until some good randomness comes from the
* kernel. One of two things will happen: it will succeed or
* it will fail (with poor randomness), thus creating NAT
* sessions will be "slow" until enough randomness is gained
* to not need to get more. It isn't necessary to initialise
* seed as it will just pickup whatever random garbage has
* been left on the heap and that's good enough until we
* get some good garbage.
*/
seeded = 1;
}
return (unsigned)ipf_r_lrand48();
}
#endif