shared_source/c_datd/esrg_rand_int.c

//$Header$
//-------------------------------------------------------------------------------------------------
//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
//integrated into many of David T. Ashley's projects.
//-------------------------------------------------------------------------------------------------
//This source code and any program in which it is compiled/used is provided under the MIT License,
//reproduced below.
//-------------------------------------------------------------------------------------------------
//Permission is hereby granted, free of charge, to any person obtaining a copy of
//this software and associated documentation files(the "Software"), to deal in the
//Software without restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
//Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions :
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//-------------------------------------------------------------------------------------------------
#define MODULE_ESRG_RAND_INT

#include <assert.h>
#include <string.h>
#include <time.h>

#include "esrg_rand_int.h"
#include "intfunc.h"


void ESRG_RAND_INT_Alg01_Init(struct ESRG_RAND_INT_Alg01RngState *state,
                              int    init_val)
   {
   int i;

   assert(state != NULL);
   assert((init_val==-1) || (init_val>0));

   //Regardless of init type, zero out the structure.  Among other things,
   //this sets the number of remaining random bits to zero.
   memset(state, 0, sizeof(*state));

   if (init_val == -1)
      {
      //This is the system randomness initialization case.  Some value
      //of system time should be adequate to start with.
      state->rn_seed_whole      = time(NULL);
      state->rn_seed_fractional = time(NULL);

      //Flip a few bits in the seeds to hopefully make them different
      //(but it doesn't matter if they aren't).
      state->rn_seed_whole      ^= 0xA5A5A5A5;
      state->rn_seed_fractional ^= 0x5A5A5A5A;

      //Be absolutely sure that the seeds can't be zero.
      state->rn_seed_whole      |= 0x1;
      state->rn_seed_fractional |= 0x2;

      //Iterate a small number of times to add further randomness
      //to the two seeds.
      for (i=0; i<3; i++)
         {
         state->rn_seed_whole 
            = INTFUNC_rn_power_res_16807_mapping(state->rn_seed_whole);
         }

      for (i=0; i<7; i++)
         {
         state->rn_seed_fractional 
            = INTFUNC_rn_power_res_16807_mapping(state->rn_seed_fractional);
         }
      }
   else
      {
      //This is the branch where the random seed is supplied.  We can
      //use very much the same approach as above to try to get something
      //random.
      state->rn_seed_whole      = init_val;
      state->rn_seed_fractional = init_val;

      //Flip a few bits in the seeds to hopefully make them different
      //(but it doesn't matter if they aren't).
      state->rn_seed_whole      ^= 0xA5A5A5A5;
      state->rn_seed_fractional ^= 0x5A5A5A5A;

      //Be absolutely sure that the seeds can't be zero.
      state->rn_seed_whole      |= 0x1;
      state->rn_seed_fractional |= 0x2;

      //Iterate a small number of times to add further randomness
      //to the two seeds.
      for (i=0; i<3; i++)
         {
         state->rn_seed_whole 
            = INTFUNC_rn_power_res_16807_mapping(state->rn_seed_whole);
         }

      for (i=0; i<7; i++)
         {
         state->rn_seed_fractional 
            = INTFUNC_rn_power_res_16807_mapping(state->rn_seed_fractional);
         }
      }

   //At this point the state is randomized.  The number of bits valid
   //in the bit reservoir is set to zero, so will force a restock
   //next time.
   }


//Restocks the bit reservoir.
static void ESRG_RAND_INT_Alg01_RestockBitBuffer(
                                                struct ESRG_RAND_INT_Alg01RngState *state
                                                )
   {
   assert(state != NULL);

   //We need to keep chugging along until we get an integer with the top two
   //bits clear.  This is the only way to get a random distribution of bits.
   do
      {
      assert(state->rn_seed_fractional != 0);
      state->rn_seed_fractional 
         = INTFUNC_rn_power_res_16807_mapping(state->rn_seed_fractional);
      } while (state->rn_seed_fractional & 0xC0000000);

   //At this point the lower 30 bits should be random.
   state->bit_buffer = state->rn_seed_fractional;
   state->n_bb_valid = 30;
   }


unsigned int ESRG_RAND_INT_Alg01_RandomBit(
                                 struct ESRG_RAND_INT_Alg01RngState *state
                                 )
   {
   int rv;

   assert(state != NULL);

   //Restock the supply of bits if necessary.
   if (state->n_bb_valid == 0)
      ESRG_RAND_INT_Alg01_RestockBitBuffer(state);

   if (state->bit_buffer & 0x01)
      rv = 1;
   else
      rv = 0;

   state->bit_buffer >>= 1;
   state->n_bb_valid--;

   return(rv);
   }


unsigned int ESRG_RAND_INT_Alg01_RandomByte(
                                 struct ESRG_RAND_INT_Alg01RngState *state
                                 )
   {
   int rv;

   assert(state != NULL);

   //Be sure enough bits to yank a byte.
   if (state->n_bb_valid < 8)
      ESRG_RAND_INT_Alg01_RestockBitBuffer(state);

   //Grab the byte and return.
   rv = state->bit_buffer & 0xFF;
   state->bit_buffer >>= 8;  //Must roll down to get new set of bits.
   state->n_bb_valid -= 8;

   return(rv);
   }


const char *ESRG_RAND_INT_cvcinfo(void)
   {
   return("$Header$");
   }


const char *ESRG_RAND_INT_hvcinfo(void)
   {
   return(ESRG_RAND_INT_H_VERSION);
   }

//End of esrg_rand_int.c.
1	dashley	71	//$Header$
2			//-------------------------------------------------------------------------------------------------
3			//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
4			//integrated into many of David T. Ashley's projects.
5			//-------------------------------------------------------------------------------------------------
6			//This source code and any program in which it is compiled/used is provided under the MIT License,
7			//reproduced below.
8			//-------------------------------------------------------------------------------------------------
9			//Permission is hereby granted, free of charge, to any person obtaining a copy of
10			//this software and associated documentation files(the "Software"), to deal in the
11			//Software without restriction, including without limitation the rights to use,
12			//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
13			//Software, and to permit persons to whom the Software is furnished to do so,
14			//subject to the following conditions :
15			//
16			//The above copyright notice and this permission notice shall be included in all
17			//copies or substantial portions of the Software.
18			//
19			//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20			//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21			//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22			//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23			//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24			//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25			//SOFTWARE.
26			//-------------------------------------------------------------------------------------------------
27			#define MODULE_ESRG_RAND_INT
28
29			#include <assert.h>
30			#include <string.h>
31			#include <time.h>
32
33			#include "esrg_rand_int.h"
34			#include "intfunc.h"
35
36
37			void ESRG_RAND_INT_Alg01_Init(struct ESRG_RAND_INT_Alg01RngState *state,
38			int init_val)
39			{
40			int i;
41
42			assert(state != NULL);
43			assert((init_val==-1) \|\| (init_val>0));
44
45			//Regardless of init type, zero out the structure. Among other things,
46			//this sets the number of remaining random bits to zero.
47			memset(state, 0, sizeof(*state));
48
49			if (init_val == -1)
50			{
51			//This is the system randomness initialization case. Some value
52			//of system time should be adequate to start with.
53			state->rn_seed_whole = time(NULL);
54			state->rn_seed_fractional = time(NULL);
55
56			//Flip a few bits in the seeds to hopefully make them different
57			//(but it doesn't matter if they aren't).
58			state->rn_seed_whole ^= 0xA5A5A5A5;
59			state->rn_seed_fractional ^= 0x5A5A5A5A;
60
61			//Be absolutely sure that the seeds can't be zero.
62			state->rn_seed_whole \|= 0x1;
63			state->rn_seed_fractional \|= 0x2;
64
65			//Iterate a small number of times to add further randomness
66			//to the two seeds.
67			for (i=0; i<3; i++)
68			{
69			state->rn_seed_whole
70			= INTFUNC_rn_power_res_16807_mapping(state->rn_seed_whole);
71			}
72
73			for (i=0; i<7; i++)
74			{
75			state->rn_seed_fractional
76			= INTFUNC_rn_power_res_16807_mapping(state->rn_seed_fractional);
77			}
78			}
79			else
80			{
81			//This is the branch where the random seed is supplied. We can
82			//use very much the same approach as above to try to get something
83			//random.
84			state->rn_seed_whole = init_val;
85			state->rn_seed_fractional = init_val;
86
87			//Flip a few bits in the seeds to hopefully make them different
88			//(but it doesn't matter if they aren't).
89			state->rn_seed_whole ^= 0xA5A5A5A5;
90			state->rn_seed_fractional ^= 0x5A5A5A5A;
91
92			//Be absolutely sure that the seeds can't be zero.
93			state->rn_seed_whole \|= 0x1;
94			state->rn_seed_fractional \|= 0x2;
95
96			//Iterate a small number of times to add further randomness
97			//to the two seeds.
98			for (i=0; i<3; i++)
99			{
100			state->rn_seed_whole
101			= INTFUNC_rn_power_res_16807_mapping(state->rn_seed_whole);
102			}
103
104			for (i=0; i<7; i++)
105			{
106			state->rn_seed_fractional
107			= INTFUNC_rn_power_res_16807_mapping(state->rn_seed_fractional);
108			}
109			}
110
111			//At this point the state is randomized. The number of bits valid
112			//in the bit reservoir is set to zero, so will force a restock
113			//next time.
114			}
115
116
117			//Restocks the bit reservoir.
118			static void ESRG_RAND_INT_Alg01_RestockBitBuffer(
119			struct ESRG_RAND_INT_Alg01RngState *state
120			)
121			{
122			assert(state != NULL);
123
124			//We need to keep chugging along until we get an integer with the top two
125			//bits clear. This is the only way to get a random distribution of bits.
126			do
127			{
128			assert(state->rn_seed_fractional != 0);
129			state->rn_seed_fractional
130			= INTFUNC_rn_power_res_16807_mapping(state->rn_seed_fractional);
131			} while (state->rn_seed_fractional & 0xC0000000);
132
133			//At this point the lower 30 bits should be random.
134			state->bit_buffer = state->rn_seed_fractional;
135			state->n_bb_valid = 30;
136			}
137
138
139			unsigned int ESRG_RAND_INT_Alg01_RandomBit(
140			struct ESRG_RAND_INT_Alg01RngState *state
141			)
142			{
143			int rv;
144
145			assert(state != NULL);
146
147			//Restock the supply of bits if necessary.
148			if (state->n_bb_valid == 0)
149			ESRG_RAND_INT_Alg01_RestockBitBuffer(state);
150
151			if (state->bit_buffer & 0x01)
152			rv = 1;
153			else
154			rv = 0;
155
156			state->bit_buffer >>= 1;
157			state->n_bb_valid--;
158
159			return(rv);
160			}
161
162
163			unsigned int ESRG_RAND_INT_Alg01_RandomByte(
164			struct ESRG_RAND_INT_Alg01RngState *state
165			)
166			{
167			int rv;
168
169			assert(state != NULL);
170
171			//Be sure enough bits to yank a byte.
172			if (state->n_bb_valid < 8)
173			ESRG_RAND_INT_Alg01_RestockBitBuffer(state);
174
175			//Grab the byte and return.
176			rv = state->bit_buffer & 0xFF;
177			state->bit_buffer >>= 8; //Must roll down to get new set of bits.
178			state->n_bb_valid -= 8;
179
180			return(rv);
181			}
182
183
184			const char *ESRG_RAND_INT_cvcinfo(void)
185			{
186			return("$Header$");
187			}
188
189
190			const char *ESRG_RAND_INT_hvcinfo(void)
191			{
192			return(ESRG_RAND_INT_H_VERSION);
193			}
194
195			//End of esrg_rand_int.c.