r250c.sh01

Nistnet网络仿真软件

---- Cut Here and unpack ----
#!/bin/sh
# shar:	Shell Archiver  (v1.22)
#
#                                                                          
#                                                                          
#
#	Run the following text with /bin/sh to create:
#	  r250.c
#	  r250.h
#	  randlcg.h
#	  randlcg.c
#
if test -r s2_seq_.tmp
then echo "Must unpack archives in sequence!"
     next=`cat s2_seq_.tmp`; echo "Please unpack part $next next"
     exit 1; fi
echo "x - extracting r250.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > r250.c &&
X/* r250.c	the r250 uniform random number algorithm
X
X		Kirkpatrick, S., and E. Stoll, 1981; "A Very Fast
X		Shift-Register Sequence Random Number Generator",
X		Journal of Computational Physics, V.40
X
X		also:
X
X		see W.L. Maier, DDJ May 1991
X
X
X
X*/
X
Xstatic char rcsid[] = "@(#)r250.c	1.2 15:50:31 11/21/94   EFC";
X
X
X#include <limits.h>
X
X#include "r250.h"
X
X/* set the following if you trust rand(), otherwise the minimal standard
X   generator is used
X*/
X/* #define TRUST_RAND */
X
X
X#ifndef TRUST_RAND
X#include "randlcg.h"
X#endif
X
X/* defines to allow for 16 or 32 bit integers */
X#define BITS 31
X
X
X#if WORD_BIT == 32
X#ifndef BITS
X#define BITS	32
X#endif
X#else
X#ifndef BITS
X#define BITS    16
X#endif
X#endif
X
X#if BITS == 31
X#define MSB          0x40000000L
X#define ALL_BITS     0x7fffffffL
X#define HALF_RANGE   0x20000000L
X#define STEP         7
X#endif
X
X#if BITS == 32
X#define MSB          0x80000000L
X#define ALL_BITS     0xffffffffL
X#define HALF_RANGE   0x40000000L
X#define STEP         7
X#endif
X
X#if BITS == 16
X#define MSB         0x8000
X#define ALL_BITS    0xffff
X#define HALF_RANGE  0x4000
X#define STEP        11
X#endif
X
Xstatic unsigned int r250_buffer[ 250 ];
Xstatic int r250_index;
X
X#ifdef NO_PROTO
Xvoid r250_init(sd)
Xint seed;
X#else
Xvoid r250_init(int sd)
X#endif
X{
X	int j, k;
X	unsigned int mask, msb;
X
X#ifdef TRUST_RAND        
X
X#if BITS == 32 || BITS == 31       
X	srand48( sd );
X#else
X	srand( sd );
X#endif	
X
X
X#else
X	set_seed( sd );
X#endif
X	
X	r250_index = 0;
X	for (j = 0; j < 250; j++)      /* fill r250 buffer with BITS-1 bit values */
X#ifdef TRUST_RAND
X#if BITS == 32 || BITS == 31
X		r250_buffer[j] = (unsigned int)lrand48();
X#else
X		r250_buffer[j] = rand();
X#endif
X#else
X		r250_buffer[j] = randlcg();
X#endif
X
X
X	for (j = 0; j < 250; j++)	/* set some MSBs to 1 */
X#ifdef TRUST_RAND
X		if ( rand() > HALF_RANGE )
X			r250_buffer[j] |= MSB;
X#else
X		if ( randlcg() > HALF_RANGE )
X			r250_buffer[j] |= MSB;
X#endif
X
X
X	msb = MSB;	        /* turn on diagonal bit */
X	mask = ALL_BITS;	/* turn off the leftmost bits */
X
X	for (j = 0; j < BITS; j++)
X	{
X		k = STEP * j + 3;	/* select a word to operate on */
X		r250_buffer[k] &= mask; /* turn off bits left of the diagonal */
X		r250_buffer[k] |= msb;	/* turn on the diagonal bit */
X		mask >>= 1;
X		msb  >>= 1;
X	}
X
X}
X
Xunsigned int r250()		/* returns a random unsigned integer */
X{
X	register int	j;
X	register unsigned int new_rand;
X
X	if ( r250_index >= 147 )
X		j = r250_index - 147;	/* wrap pointer around */
X	else
X		j = r250_index + 103;
X
X	new_rand = r250_buffer[ r250_index ] ^ r250_buffer[ j ];
X	r250_buffer[ r250_index ] = new_rand;
X
X	if ( r250_index >= 249 )	/* increment pointer for next time */
X		r250_index = 0;
X	else
X		r250_index++;
X
X	return new_rand;
X
X}
X
X
Xdouble dr250()		/* returns a random double in range 0..1 */
X{
X	register int	j;
X	register unsigned int new_rand;
X
X	if ( r250_index >= 147 )
X		j = r250_index - 147;	/* wrap pointer around */
X	else
X		j = r250_index + 103;
X
X	new_rand = r250_buffer[ r250_index ] ^ r250_buffer[ j ];
X	r250_buffer[ r250_index ] = new_rand;
X
X	if ( r250_index >= 249 )	/* increment pointer for next time */
X		r250_index = 0;
X	else
X		r250_index++;
X
X	return (double)new_rand / ALL_BITS;
X
X}
X
X#ifdef MAIN
X
X/* test driver	prints out either NMR_RAND values or a histogram	*/
X
X#include <stdio.h>
X
X#define NMR_RAND	5000
X#define MAX_BINS	500
X
X#ifdef NO_PROTO
Xvoid main(argc, argv)
Xint argc;
Xchar **argv;
X#else
Xvoid main(int argc, char **argv)
X#endif
X{
X	int j,k,nmr_bins,seed;
X	int bins[MAX_BINS];
X	double randm, bin_inc;
X	double bin_limit[MAX_BINS];
X
X	if ( argc != 3 )
X	{
X		printf("Usage -- %s nmr_bins seed\n", argv[0]);
X		exit(1);
X	}
X
X	nmr_bins = atoi( argv[1] );
X	if ( nmr_bins > MAX_BINS )
X	{
X		printf("ERROR -- maximum number of bins is %d\n", MAX_BINS);
X		exit(1);
X	}
X
X	seed = atoi( argv[2] );
X
X	r250_init( seed );
X
X	if ( nmr_bins < 1 )	/* just print out the numbers */
X	{
X		for (j = 0; j < NMR_RAND; j++)
X			printf("%f\n", dr250() );
X		exit(0);
X	}
X	
X	bin_inc = 1.0 / nmr_bins;
X	for (j = 0; j < nmr_bins; j++)	/* initialize bins to zero */
X	{
X		bins[j] = 0;
X		bin_limit[j] = (j + 1) * bin_inc;
X	}
X
X	bin_limit[nmr_bins-1] = 1.0e7;	/* make sure all others are in last bin */
X
X	for (j = 0; j < NMR_RAND; j++)
X	{
X		randm = r250() / (double)ALL_BITS;
X		for (k = 0; k < nmr_bins; k++)
X			if ( randm < bin_limit[k] )
X			{
X				bins[k]++;
X				break;
X			}
X	}
X
X
X	for (j = 0; j < nmr_bins; j++)
X		printf("%d\n", bins[j]);
X	
X}
X
X#endif
X
SHAR_EOF
chmod 0444 r250.c || echo "restore of r250.c fails"
echo "x - extracting r250.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > r250.h &&
X/* r250.h	prototypes for r250 random number generator,
X
X		Kirkpatrick, S., and E. Stoll, 1981; "A Very Fast
X		Shift-Register Sequence Random Number Generator",
X		Journal of Computational Physics, V.40
X
X		also:
X
X		see W.L. Maier, DDJ May 1991
X
X
X*/
X
X#ifndef _R250_H_
X#define _R250_H_ 1.2
X
X#ifdef __cplusplus
Xextern "C" {
X#endif
X
X#ifdef NO_PROTO
Xvoid         r250_init();
Xunsigned int r250();
Xdouble      dr250();
X
X#else
Xvoid         r250_init(int seed);
Xunsigned int r250( void );
Xdouble       dr250( void );
X#endif
X
X#ifdef __cplusplus
X}
X#endif
X
X#endif
SHAR_EOF
chmod 0444 r250.h || echo "restore of r250.h fails"
echo "x - extracting randlcg.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > randlcg.h &&
X
X/* randlcg.h	prototypes for the minimal standard random number generator,
X
X   Linear Congruential Method, the "minimal standard generator"
X   Park & Miller, 1988, Comm of the ACM, 31(10), pp. 1192-1201
X
X
X  rcsid: @(#)randlcg.h	1.1 15:48:09 11/21/94   EFC
X
X*/
X
X#ifndef _RANDLCG_H_
X#define _RANDLCG_H_ 1.1
X
X#ifdef __cplusplus
Xextern "C" {
X#endif
X
X#ifdef NO_PROTO
Xlong         set_seed();
Xlong         get_seed();
Xunsigned long int randlcg();
X
X#else
Xlong         set_seed(long);
Xlong         get_seed(long);
Xunsigned long int randlcg();
X
X#endif
X
X#ifdef __cplusplus
X}
X#endif
X
X#endif
SHAR_EOF
chmod 0444 randlcg.h || echo "restore of randlcg.h fails"
echo "x - extracting randlcg.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > randlcg.c &&
X/* rndlcg            Linear Congruential Method, the "minimal standard generator"
X                     Park & Miller, 1988, Comm of the ACM, 31(10), pp. 1192-1201
X
X*/
X
Xstatic char rcsid[] = "@(#)randlcg.c	1.1 15:48:15 11/21/94   EFC";
X
X#include <math.h>
X#include <limits.h>
X
X#define ALL_BITS     0xffffffff
X
Xstatic long int quotient  = LONG_MAX / 16807L;
Xstatic long int remainder = LONG_MAX % 16807L;
X
Xstatic long int seed_val = 1L;
X
Xlong set_seed(long int sd)
X{
X        return seed_val = sd;
X}
X
Xlong get_seed()
X{
X        return seed_val;
X}
X
X
Xunsigned long int randlcg()       /* returns a random unsigned integer */
X{
X        if ( seed_val <= quotient )
X                seed_val = (seed_val * 16807L) % LONG_MAX;
X        else
X        {
X                long int high_part = seed_val / quotient;
X                long int low_part  = seed_val % quotient;
X
X                long int test = 16807L * low_part - remainder * high_part;
X
X                if ( test > 0 )
X                        seed_val = test;
X                else
X                        seed_val = test + LONG_MAX;
X
X        }
X
X        return seed_val;
X}
X
X
X
X
X
SHAR_EOF
chmod 0444 randlcg.c || echo "restore of randlcg.c fails"
exit 0