src/parsec/disk-image/parsec/parsec-benchmark/pkgs/libs/gsl/src/rng/random.c - public/gem5-resources - Git at Google

 /* rng/random.c
  *
  * Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or (at
  * your option) any later version.
  *
  * This program 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
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */

 #include <config.h>
 #include <stdlib.h>
 #include <gsl/gsl_rng.h>

 /* This file provides support for random() generators. There are three
    versions in widespread use today,

    - The original BSD version, e.g. on SunOS 4.1 and FreeBSD.

    - The Linux libc5 version, which is differs from the BSD version in
    its seeding procedure, possibly due to the introduction of a typo
    in the multiplier.

    - The GNU glibc2 version, which has a new (and better) seeding
    procedure.

    They all produce different numbers, due to the different seeding
    algorithms, but the algorithm for the generator is the same in each
    case.

  */

 static inline long int random_get (int * i, int * j, int n, long int * x);

 static inline unsigned long int random8_get (void *vstate);
 static inline unsigned long int random32_get (void *vstate);
 static inline unsigned long int random64_get (void *vstate);
 static inline unsigned long int random128_get (void *vstate);
 static inline unsigned long int random256_get (void *vstate);

 static double random8_get_double (void *vstate);
 static double random32_get_double (void *vstate);
 static double random64_get_double (void *vstate);
 static double random128_get_double (void *vstate);
 static double random256_get_double (void *vstate);

 static void random8_glibc2_set (void *state, unsigned long int s);
 static void random32_glibc2_set (void *state, unsigned long int s);
 static void random64_glibc2_set (void *state, unsigned long int s);
 static void random128_glibc2_set (void *state, unsigned long int s);
 static void random256_glibc2_set (void *state, unsigned long int s);

 static void random8_libc5_set (void *state, unsigned long int s);
 static void random32_libc5_set (void *state, unsigned long int s);
 static void random64_libc5_set (void *state, unsigned long int s);
 static void random128_libc5_set (void *state, unsigned long int s);
 static void random256_libc5_set (void *state, unsigned long int s);

 static void random8_bsd_set (void *state, unsigned long int s);
 static void random32_bsd_set (void *state, unsigned long int s);
 static void random64_bsd_set (void *state, unsigned long int s);
 static void random128_bsd_set (void *state, unsigned long int s);
 static void random256_bsd_set (void *state, unsigned long int s);

 static void bsd_initialize (long int * x, int n, unsigned long int s);
 static void libc5_initialize (long int * x, int n, unsigned long int s);
 static void glibc2_initialize (long int * x, int n, unsigned long int s);

 typedef struct
   {
     long int x;
   }
 random8_state_t;

 typedef struct
   {
     int i, j;
     long int x[7];
   }
 random32_state_t;

 typedef struct
   {
     int i, j;
     long int x[15];
   }
 random64_state_t;

 typedef struct
   {
     int i, j;
     long int x[31];
   }
 random128_state_t;

 typedef struct
   {
     int i, j;
     long int x[63];
   }
 random256_state_t;

 static inline unsigned long int
 random8_get (void *vstate)
 {
   random8_state_t *state = (random8_state_t *) vstate;

   state->x = (1103515245 * state->x + 12345) & 0x7fffffffUL;
   return state->x;
 }

 static inline long int
 random_get (int * i, int * j, int n, long int * x)
 {
   long int k ;

   x[*i] += x[*j] ;
   k = (x[*i] >> 1) & 0x7FFFFFFF ;

   (*i)++ ;
   if (*i == n)
     *i = 0 ;

   (*j)++ ;
   if (*j == n)
     *j = 0 ;

   return k ;
 }

 static inline unsigned long int
 random32_get (void *vstate)
 {
   random32_state_t *state = (random32_state_t *) vstate;
   unsigned long int k = random_get (&state->i, &state->j, 7, state->x) ;
   return k ;
 }

 static inline unsigned long int
 random64_get (void *vstate)
 {
   random64_state_t *state = (random64_state_t *) vstate;
   long int k = random_get (&state->i, &state->j, 15, state->x) ;
   return k ;
 }

 static inline unsigned long int
 random128_get (void *vstate)
 {
   random128_state_t *state = (random128_state_t *) vstate;
   unsigned long int k = random_get (&state->i, &state->j, 31, state->x) ;
   return k ;
 }

 static inline unsigned long int
 random256_get (void *vstate)
 {
   random256_state_t *state = (random256_state_t *) vstate;
   long int k = random_get (&state->i, &state->j, 63, state->x) ;
   return k ;
 }

 static double
 random8_get_double (void *vstate)
 {
   return random8_get (vstate) / 2147483648.0 ;
 }

 static double
 random32_get_double (void *vstate)
 {
   return random32_get (vstate) / 2147483648.0 ;
 }

 static double
 random64_get_double (void *vstate)
 {
   return random64_get (vstate) / 2147483648.0 ;
 }

 static double
 random128_get_double (void *vstate)
 {
   return random128_get (vstate) / 2147483648.0 ;
 }

 static double
 random256_get_double (void *vstate)
 {
   return random256_get (vstate) / 2147483648.0 ;
 }

 static void
 random8_bsd_set (void *vstate, unsigned long int s)
 {
   random8_state_t *state = (random8_state_t *) vstate;

   if (s == 0)
     s = 1;

   state->x = s;
 }

 static void
 random32_bsd_set (void *vstate, unsigned long int s)
 {
   random32_state_t *state = (random32_state_t *) vstate;
   int i;

   bsd_initialize (state->x, 7, s) ;

   state->i = 3;
   state->j = 0;

   for (i = 0 ; i < 10 * 7 ; i++)
     random32_get (state) ;
 }

 static void
 random64_bsd_set (void *vstate, unsigned long int s)
 {
   random64_state_t *state = (random64_state_t *) vstate;
   int i;

   bsd_initialize (state->x, 15, s) ;

   state->i = 1;
   state->j = 0;

   for (i = 0 ; i < 10 * 15 ; i++)
     random64_get (state) ;
 }

 static void
 random128_bsd_set (void *vstate, unsigned long int s)
 {
   random128_state_t *state = (random128_state_t *) vstate;
   int i;

   bsd_initialize (state->x, 31, s) ;

   state->i = 3;
   state->j = 0;

   for (i = 0 ; i < 10 * 31 ; i++)
     random128_get (state) ;
 }

 static void
 random256_bsd_set (void *vstate, unsigned long int s)
 {
   random256_state_t *state = (random256_state_t *) vstate;
   int i;

   bsd_initialize (state->x, 63, s) ;

   state->i = 1;
   state->j = 0;

   for (i = 0 ; i < 10 * 63 ; i++)
     random256_get (state) ;
 }

 static void
 bsd_initialize (long int * x, int n, unsigned long int s)
 {
   int i;

   if (s == 0)
     s = 1 ;

   x[0] = s;

   for (i = 1 ; i < n ; i++)
     x[i] = 1103515245 * x[i-1] + 12345 ;
 }

 static void
 libc5_initialize (long int * x, int n, unsigned long int s)
 {
   int i;

   if (s == 0)
     s = 1 ;

   x[0] = s;

   for (i = 1 ; i < n ; i++)
     x[i] = 1103515145 * x[i-1] + 12345 ;
 }

 static void
 glibc2_initialize (long int * x, int n, unsigned long int s)
 {
   int i;

   if (s == 0)
     s = 1 ;

   x[0] = s;

   for (i = 1 ; i < n ; i++)
     {
       const long int h = s / 127773;
       const long int t = 16807 * (s - h * 127773) - h * 2836;
       if (t < 0)
         {
           s = t + 2147483647 ;
         }
       else
         {
           s = t ;
         }

     x[i] = s ;
     }
 }

 static void
 random8_glibc2_set (void *vstate, unsigned long int s)
 {
   random8_state_t *state = (random8_state_t *) vstate;

   if (s == 0)
     s = 1;

   state->x = s;
 }

 static void
 random32_glibc2_set (void *vstate, unsigned long int s)
 {
   random32_state_t *state = (random32_state_t *) vstate;
   int i;

   glibc2_initialize (state->x, 7, s) ;

   state->i = 3;
   state->j = 0;

   for (i = 0 ; i < 10 * 7 ; i++)
     random32_get (state) ;
 }

 static void
 random64_glibc2_set (void *vstate, unsigned long int s)
 {
   random64_state_t *state = (random64_state_t *) vstate;
   int i;

   glibc2_initialize (state->x, 15, s) ;

   state->i = 1;
   state->j = 0;

   for (i = 0 ; i < 10 * 15 ; i++)
     random64_get (state) ;
 }

 static void
 random128_glibc2_set (void *vstate, unsigned long int s)
 {
   random128_state_t *state = (random128_state_t *) vstate;
   int i;

   glibc2_initialize (state->x, 31, s) ;

   state->i = 3;
   state->j = 0;

   for (i = 0 ; i < 10 * 31 ; i++)
     random128_get (state) ;
 }

 static void
 random256_glibc2_set (void *vstate, unsigned long int s)
 {
   random256_state_t *state = (random256_state_t *) vstate;
   int i;

   glibc2_initialize (state->x, 63, s) ;

   state->i = 1;
   state->j = 0;

   for (i = 0 ; i < 10 * 63 ; i++)
     random256_get (state) ;
 }


 static void
 random8_libc5_set (void *vstate, unsigned long int s)
 {
   random8_state_t *state = (random8_state_t *) vstate;

   if (s == 0)
     s = 1;

   state->x = s;
 }

 static void
 random32_libc5_set (void *vstate, unsigned long int s)
 {
   random32_state_t *state = (random32_state_t *) vstate;
   int i;

   libc5_initialize (state->x, 7, s) ;

   state->i = 3;
   state->j = 0;

   for (i = 0 ; i < 10 * 7 ; i++)
     random32_get (state) ;
 }

 static void
 random64_libc5_set (void *vstate, unsigned long int s)
 {
   random64_state_t *state = (random64_state_t *) vstate;
   int i;

   libc5_initialize (state->x, 15, s) ;

   state->i = 1;
   state->j = 0;

   for (i = 0 ; i < 10 * 15 ; i++)
     random64_get (state) ;
 }

 static void
 random128_libc5_set (void *vstate, unsigned long int s)
 {
   random128_state_t *state = (random128_state_t *) vstate;
   int i;

   libc5_initialize (state->x, 31, s) ;

   state->i = 3;
   state->j = 0;

   for (i = 0 ; i < 10 * 31 ; i++)
     random128_get (state) ;
 }

 static void
 random256_libc5_set (void *vstate, unsigned long int s)
 {
   random256_state_t *state = (random256_state_t *) vstate;
   int i;

   libc5_initialize (state->x, 63, s) ;

   state->i = 1;
   state->j = 0;

   for (i = 0 ; i < 10 * 63 ; i++)
     random256_get (state) ;
 }

 static const gsl_rng_type random_glibc2_type =
 {"random-glibc2",                       /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random128_state_t),
  &random128_glibc2_set,
  &random128_get,
  &random128_get_double};

 static const gsl_rng_type random8_glibc2_type =
 {"random8-glibc2",                      /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random8_state_t),
  &random8_glibc2_set,
  &random8_get,
  &random8_get_double};

 static const gsl_rng_type random32_glibc2_type =
 {"random32-glibc2",                     /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random32_state_t),
  &random32_glibc2_set,
  &random32_get,
  &random32_get_double};

 static const gsl_rng_type random64_glibc2_type =
 {"random64-glibc2",                     /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random64_state_t),
  &random64_glibc2_set,
  &random64_get,
  &random64_get_double};

 static const gsl_rng_type random128_glibc2_type =
 {"random128-glibc2",                    /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random128_state_t),
  &random128_glibc2_set,
  &random128_get,
  &random128_get_double};

 static const gsl_rng_type random256_glibc2_type =
 {"random256-glibc2",                    /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random256_state_t),
  &random256_glibc2_set,
  &random256_get,
  &random256_get_double};

 static const gsl_rng_type random_libc5_type =
 {"random-libc5",                        /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random128_state_t),
  &random128_libc5_set,
  &random128_get,
  &random128_get_double};

 static const gsl_rng_type random8_libc5_type =
 {"random8-libc5",                       /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random8_state_t),
  &random8_libc5_set,
  &random8_get,
  &random8_get_double};

 static const gsl_rng_type random32_libc5_type =
 {"random32-libc5",                      /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random32_state_t),
  &random32_libc5_set,
  &random32_get,
  &random32_get_double};

 static const gsl_rng_type random64_libc5_type =
 {"random64-libc5",                      /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random64_state_t),
  &random64_libc5_set,
  &random64_get,
  &random64_get_double};

 static const gsl_rng_type random128_libc5_type =
 {"random128-libc5",                     /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random128_state_t),
  &random128_libc5_set,
  &random128_get,
  &random128_get_double};

 static const gsl_rng_type random256_libc5_type =
 {"random256-libc5",                     /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random256_state_t),
  &random256_libc5_set,
  &random256_get,
  &random256_get_double};

 static const gsl_rng_type random_bsd_type =
 {"random-bsd",                  /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random128_state_t),
  &random128_bsd_set,
  &random128_get,
  &random128_get_double};

 static const gsl_rng_type random8_bsd_type =
 {"random8-bsd",                 /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random8_state_t),
  &random8_bsd_set,
  &random8_get,
  &random8_get_double};

 static const gsl_rng_type random32_bsd_type =
 {"random32-bsd",                        /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random32_state_t),
  &random32_bsd_set,
  &random32_get,
  &random32_get_double};

 static const gsl_rng_type random64_bsd_type =
 {"random64-bsd",                        /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random64_state_t),
  &random64_bsd_set,
  &random64_get,
  &random64_get_double};

 static const gsl_rng_type random128_bsd_type =
 {"random128-bsd",               /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random128_state_t),
  &random128_bsd_set,
  &random128_get,
  &random128_get_double};

 static const gsl_rng_type random256_bsd_type =
 {"random256-bsd",               /* name */
  0x7fffffffUL,                  /* RAND_MAX */
  0,                             /* RAND_MIN */
  sizeof (random256_state_t),
  &random256_bsd_set,
  &random256_get,
  &random256_get_double};

 const gsl_rng_type *gsl_rng_random_libc5    = &random_libc5_type;
 const gsl_rng_type *gsl_rng_random8_libc5   = &random8_libc5_type;
 const gsl_rng_type *gsl_rng_random32_libc5  = &random32_libc5_type;
 const gsl_rng_type *gsl_rng_random64_libc5  = &random64_libc5_type;
 const gsl_rng_type *gsl_rng_random128_libc5 = &random128_libc5_type;
 const gsl_rng_type *gsl_rng_random256_libc5 = &random256_libc5_type;

 const gsl_rng_type *gsl_rng_random_glibc2    = &random_glibc2_type;
 const gsl_rng_type *gsl_rng_random8_glibc2   = &random8_glibc2_type;
 const gsl_rng_type *gsl_rng_random32_glibc2  = &random32_glibc2_type;
 const gsl_rng_type *gsl_rng_random64_glibc2  = &random64_glibc2_type;
 const gsl_rng_type *gsl_rng_random128_glibc2 = &random128_glibc2_type;
 const gsl_rng_type *gsl_rng_random256_glibc2 = &random256_glibc2_type;

 const gsl_rng_type *gsl_rng_random_bsd    = &random_bsd_type;
 const gsl_rng_type *gsl_rng_random8_bsd   = &random8_bsd_type;
 const gsl_rng_type *gsl_rng_random32_bsd  = &random32_bsd_type;
 const gsl_rng_type *gsl_rng_random64_bsd  = &random64_bsd_type;
 const gsl_rng_type *gsl_rng_random128_bsd = &random128_bsd_type;
 const gsl_rng_type *gsl_rng_random256_bsd = &random256_bsd_type;
	/* rng/random.c
	*
	* Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or (at
	* your option) any later version.
	*
	* This program 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
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/

	#include <config.h>
	#include <stdlib.h>
	#include <gsl/gsl_rng.h>

	/* This file provides support for random() generators. There are three
	versions in widespread use today,

	- The original BSD version, e.g. on SunOS 4.1 and FreeBSD.

	- The Linux libc5 version, which is differs from the BSD version in
	its seeding procedure, possibly due to the introduction of a typo
	in the multiplier.

	- The GNU glibc2 version, which has a new (and better) seeding
	procedure.

	They all produce different numbers, due to the different seeding
	algorithms, but the algorithm for the generator is the same in each
	case.

	*/

	static inline long int random_get (int * i, int * j, int n, long int * x);

	static inline unsigned long int random8_get (void *vstate);
	static inline unsigned long int random32_get (void *vstate);
	static inline unsigned long int random64_get (void *vstate);
	static inline unsigned long int random128_get (void *vstate);
	static inline unsigned long int random256_get (void *vstate);

	static double random8_get_double (void *vstate);
	static double random32_get_double (void *vstate);
	static double random64_get_double (void *vstate);
	static double random128_get_double (void *vstate);
	static double random256_get_double (void *vstate);

	static void random8_glibc2_set (void *state, unsigned long int s);
	static void random32_glibc2_set (void *state, unsigned long int s);
	static void random64_glibc2_set (void *state, unsigned long int s);
	static void random128_glibc2_set (void *state, unsigned long int s);
	static void random256_glibc2_set (void *state, unsigned long int s);

	static void random8_libc5_set (void *state, unsigned long int s);
	static void random32_libc5_set (void *state, unsigned long int s);
	static void random64_libc5_set (void *state, unsigned long int s);
	static void random128_libc5_set (void *state, unsigned long int s);
	static void random256_libc5_set (void *state, unsigned long int s);

	static void random8_bsd_set (void *state, unsigned long int s);
	static void random32_bsd_set (void *state, unsigned long int s);
	static void random64_bsd_set (void *state, unsigned long int s);
	static void random128_bsd_set (void *state, unsigned long int s);
	static void random256_bsd_set (void *state, unsigned long int s);

	static void bsd_initialize (long int * x, int n, unsigned long int s);
	static void libc5_initialize (long int * x, int n, unsigned long int s);
	static void glibc2_initialize (long int * x, int n, unsigned long int s);

	typedef struct
	{
	long int x;
	}
	random8_state_t;

	typedef struct
	{
	int i, j;
	long int x[7];
	}
	random32_state_t;

	typedef struct
	{
	int i, j;
	long int x[15];
	}
	random64_state_t;

	typedef struct
	{
	int i, j;
	long int x[31];
	}
	random128_state_t;

	typedef struct
	{
	int i, j;
	long int x[63];
	}
	random256_state_t;

	static inline unsigned long int
	random8_get (void *vstate)
	{
	random8_state_t state = (random8_state_t ) vstate;

	state->x = (1103515245 * state->x + 12345) & 0x7fffffffUL;
	return state->x;
	}

	static inline long int
	random_get (int * i, int * j, int n, long int * x)
	{
	long int k ;

	x[i] += x[j] ;
	k = (x[*i] >> 1) & 0x7FFFFFFF ;

	(*i)++ ;
	if (*i == n)
	*i = 0 ;

	(*j)++ ;
	if (*j == n)
	*j = 0 ;

	return k ;
	}

	static inline unsigned long int
	random32_get (void *vstate)
	{
	random32_state_t state = (random32_state_t ) vstate;
	unsigned long int k = random_get (&state->i, &state->j, 7, state->x) ;
	return k ;
	}

	static inline unsigned long int
	random64_get (void *vstate)
	{
	random64_state_t state = (random64_state_t ) vstate;
	long int k = random_get (&state->i, &state->j, 15, state->x) ;
	return k ;
	}

	static inline unsigned long int
	random128_get (void *vstate)
	{
	random128_state_t state = (random128_state_t ) vstate;
	unsigned long int k = random_get (&state->i, &state->j, 31, state->x) ;
	return k ;
	}

	static inline unsigned long int
	random256_get (void *vstate)
	{
	random256_state_t state = (random256_state_t ) vstate;
	long int k = random_get (&state->i, &state->j, 63, state->x) ;
	return k ;
	}

	static double
	random8_get_double (void *vstate)
	{
	return random8_get (vstate) / 2147483648.0 ;
	}

	static double
	random32_get_double (void *vstate)
	{
	return random32_get (vstate) / 2147483648.0 ;
	}

	static double
	random64_get_double (void *vstate)
	{
	return random64_get (vstate) / 2147483648.0 ;
	}

	static double
	random128_get_double (void *vstate)
	{
	return random128_get (vstate) / 2147483648.0 ;
	}

	static double
	random256_get_double (void *vstate)
	{
	return random256_get (vstate) / 2147483648.0 ;
	}

	static void
	random8_bsd_set (void *vstate, unsigned long int s)
	{
	random8_state_t state = (random8_state_t ) vstate;

	if (s == 0)
	s = 1;

	state->x = s;
	}

	static void
	random32_bsd_set (void *vstate, unsigned long int s)
	{
	random32_state_t state = (random32_state_t ) vstate;
	int i;

	bsd_initialize (state->x, 7, s) ;

	state->i = 3;
	state->j = 0;

	for (i = 0 ; i < 10 * 7 ; i++)
	random32_get (state) ;
	}

	static void
	random64_bsd_set (void *vstate, unsigned long int s)
	{
	random64_state_t state = (random64_state_t ) vstate;
	int i;

	bsd_initialize (state->x, 15, s) ;

	state->i = 1;
	state->j = 0;

	for (i = 0 ; i < 10 * 15 ; i++)
	random64_get (state) ;
	}

	static void
	random128_bsd_set (void *vstate, unsigned long int s)
	{
	random128_state_t state = (random128_state_t ) vstate;
	int i;

	bsd_initialize (state->x, 31, s) ;

	state->i = 3;
	state->j = 0;

	for (i = 0 ; i < 10 * 31 ; i++)
	random128_get (state) ;
	}

	static void
	random256_bsd_set (void *vstate, unsigned long int s)
	{
	random256_state_t state = (random256_state_t ) vstate;
	int i;

	bsd_initialize (state->x, 63, s) ;

	state->i = 1;
	state->j = 0;

	for (i = 0 ; i < 10 * 63 ; i++)
	random256_get (state) ;
	}

	static void
	bsd_initialize (long int * x, int n, unsigned long int s)
	{
	int i;

	if (s == 0)
	s = 1 ;

	x[0] = s;

	for (i = 1 ; i < n ; i++)
	x[i] = 1103515245 * x[i-1] + 12345 ;
	}

	static void
	libc5_initialize (long int * x, int n, unsigned long int s)
	{
	int i;

	if (s == 0)
	s = 1 ;

	x[0] = s;

	for (i = 1 ; i < n ; i++)
	x[i] = 1103515145 * x[i-1] + 12345 ;
	}

	static void
	glibc2_initialize (long int * x, int n, unsigned long int s)
	{
	int i;

	if (s == 0)
	s = 1 ;

	x[0] = s;

	for (i = 1 ; i < n ; i++)
	{
	const long int h = s / 127773;
	const long int t = 16807 * (s - h * 127773) - h * 2836;
	if (t < 0)
	{
	s = t + 2147483647 ;
	}
	else
	{
	s = t ;
	}

	x[i] = s ;
	}
	}

	static void
	random8_glibc2_set (void *vstate, unsigned long int s)
	{
	random8_state_t state = (random8_state_t ) vstate;

	if (s == 0)
	s = 1;

	state->x = s;
	}

	static void
	random32_glibc2_set (void *vstate, unsigned long int s)
	{
	random32_state_t state = (random32_state_t ) vstate;
	int i;

	glibc2_initialize (state->x, 7, s) ;

	state->i = 3;
	state->j = 0;

	for (i = 0 ; i < 10 * 7 ; i++)
	random32_get (state) ;
	}

	static void
	random64_glibc2_set (void *vstate, unsigned long int s)
	{
	random64_state_t state = (random64_state_t ) vstate;
	int i;

	glibc2_initialize (state->x, 15, s) ;

	state->i = 1;
	state->j = 0;

	for (i = 0 ; i < 10 * 15 ; i++)
	random64_get (state) ;
	}

	static void
	random128_glibc2_set (void *vstate, unsigned long int s)
	{
	random128_state_t state = (random128_state_t ) vstate;
	int i;

	glibc2_initialize (state->x, 31, s) ;

	state->i = 3;
	state->j = 0;

	for (i = 0 ; i < 10 * 31 ; i++)
	random128_get (state) ;
	}

	static void
	random256_glibc2_set (void *vstate, unsigned long int s)
	{
	random256_state_t state = (random256_state_t ) vstate;
	int i;

	glibc2_initialize (state->x, 63, s) ;

	state->i = 1;
	state->j = 0;

	for (i = 0 ; i < 10 * 63 ; i++)
	random256_get (state) ;
	}


	static void
	random8_libc5_set (void *vstate, unsigned long int s)
	{
	random8_state_t state = (random8_state_t ) vstate;

	if (s == 0)
	s = 1;

	state->x = s;
	}

	static void
	random32_libc5_set (void *vstate, unsigned long int s)
	{
	random32_state_t state = (random32_state_t ) vstate;
	int i;

	libc5_initialize (state->x, 7, s) ;

	state->i = 3;
	state->j = 0;

	for (i = 0 ; i < 10 * 7 ; i++)
	random32_get (state) ;
	}

	static void
	random64_libc5_set (void *vstate, unsigned long int s)
	{
	random64_state_t state = (random64_state_t ) vstate;
	int i;

	libc5_initialize (state->x, 15, s) ;

	state->i = 1;
	state->j = 0;

	for (i = 0 ; i < 10 * 15 ; i++)
	random64_get (state) ;
	}

	static void
	random128_libc5_set (void *vstate, unsigned long int s)
	{
	random128_state_t state = (random128_state_t ) vstate;
	int i;

	libc5_initialize (state->x, 31, s) ;

	state->i = 3;
	state->j = 0;

	for (i = 0 ; i < 10 * 31 ; i++)
	random128_get (state) ;
	}

	static void
	random256_libc5_set (void *vstate, unsigned long int s)
	{
	random256_state_t state = (random256_state_t ) vstate;
	int i;

	libc5_initialize (state->x, 63, s) ;

	state->i = 1;
	state->j = 0;

	for (i = 0 ; i < 10 * 63 ; i++)
	random256_get (state) ;
	}

	static const gsl_rng_type random_glibc2_type =
	{"random-glibc2", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random128_state_t),
	&random128_glibc2_set,
	&random128_get,
	&random128_get_double};

	static const gsl_rng_type random8_glibc2_type =
	{"random8-glibc2", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random8_state_t),
	&random8_glibc2_set,
	&random8_get,
	&random8_get_double};

	static const gsl_rng_type random32_glibc2_type =
	{"random32-glibc2", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random32_state_t),
	&random32_glibc2_set,
	&random32_get,
	&random32_get_double};

	static const gsl_rng_type random64_glibc2_type =
	{"random64-glibc2", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random64_state_t),
	&random64_glibc2_set,
	&random64_get,
	&random64_get_double};

	static const gsl_rng_type random128_glibc2_type =
	{"random128-glibc2", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random128_state_t),
	&random128_glibc2_set,
	&random128_get,
	&random128_get_double};

	static const gsl_rng_type random256_glibc2_type =
	{"random256-glibc2", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random256_state_t),
	&random256_glibc2_set,
	&random256_get,
	&random256_get_double};

	static const gsl_rng_type random_libc5_type =
	{"random-libc5", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random128_state_t),
	&random128_libc5_set,
	&random128_get,
	&random128_get_double};

	static const gsl_rng_type random8_libc5_type =
	{"random8-libc5", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random8_state_t),
	&random8_libc5_set,
	&random8_get,
	&random8_get_double};

	static const gsl_rng_type random32_libc5_type =
	{"random32-libc5", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random32_state_t),
	&random32_libc5_set,
	&random32_get,
	&random32_get_double};

	static const gsl_rng_type random64_libc5_type =
	{"random64-libc5", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random64_state_t),
	&random64_libc5_set,
	&random64_get,
	&random64_get_double};

	static const gsl_rng_type random128_libc5_type =
	{"random128-libc5", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random128_state_t),
	&random128_libc5_set,
	&random128_get,
	&random128_get_double};

	static const gsl_rng_type random256_libc5_type =
	{"random256-libc5", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random256_state_t),
	&random256_libc5_set,
	&random256_get,
	&random256_get_double};

	static const gsl_rng_type random_bsd_type =
	{"random-bsd", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random128_state_t),
	&random128_bsd_set,
	&random128_get,
	&random128_get_double};

	static const gsl_rng_type random8_bsd_type =
	{"random8-bsd", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random8_state_t),
	&random8_bsd_set,
	&random8_get,
	&random8_get_double};

	static const gsl_rng_type random32_bsd_type =
	{"random32-bsd", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random32_state_t),
	&random32_bsd_set,
	&random32_get,
	&random32_get_double};

	static const gsl_rng_type random64_bsd_type =
	{"random64-bsd", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random64_state_t),
	&random64_bsd_set,
	&random64_get,
	&random64_get_double};

	static const gsl_rng_type random128_bsd_type =
	{"random128-bsd", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random128_state_t),
	&random128_bsd_set,
	&random128_get,
	&random128_get_double};

	static const gsl_rng_type random256_bsd_type =
	{"random256-bsd", /* name */
	0x7fffffffUL, /* RAND_MAX */
	0, /* RAND_MIN */
	sizeof (random256_state_t),
	&random256_bsd_set,
	&random256_get,
	&random256_get_double};

	const gsl_rng_type *gsl_rng_random_libc5 = &random_libc5_type;
	const gsl_rng_type *gsl_rng_random8_libc5 = &random8_libc5_type;
	const gsl_rng_type *gsl_rng_random32_libc5 = &random32_libc5_type;
	const gsl_rng_type *gsl_rng_random64_libc5 = &random64_libc5_type;
	const gsl_rng_type *gsl_rng_random128_libc5 = &random128_libc5_type;
	const gsl_rng_type *gsl_rng_random256_libc5 = &random256_libc5_type;

	const gsl_rng_type *gsl_rng_random_glibc2 = &random_glibc2_type;
	const gsl_rng_type *gsl_rng_random8_glibc2 = &random8_glibc2_type;
	const gsl_rng_type *gsl_rng_random32_glibc2 = &random32_glibc2_type;
	const gsl_rng_type *gsl_rng_random64_glibc2 = &random64_glibc2_type;
	const gsl_rng_type *gsl_rng_random128_glibc2 = &random128_glibc2_type;
	const gsl_rng_type *gsl_rng_random256_glibc2 = &random256_glibc2_type;

	const gsl_rng_type *gsl_rng_random_bsd = &random_bsd_type;
	const gsl_rng_type *gsl_rng_random8_bsd = &random8_bsd_type;
	const gsl_rng_type *gsl_rng_random32_bsd = &random32_bsd_type;
	const gsl_rng_type *gsl_rng_random64_bsd = &random64_bsd_type;
	const gsl_rng_type *gsl_rng_random128_bsd = &random128_bsd_type;
	const gsl_rng_type *gsl_rng_random256_bsd = &random256_bsd_type;