File: Random.cxx

package info (click to toggle)
stella 0.7-2
  • links: PTS
  • area: non-free
  • in suites: hamm, slink
  • size: 864 kB
  • ctags: 1,158
  • sloc: cpp: 6,615; ansic: 492; makefile: 224; asm: 31
file content (108 lines) | stat: -rw-r--r-- 3,365 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
//============================================================================
//
//    SSSS    tt          lll  lll              
//   SS  SS   tt           ll   ll                
//   SS     tttttt  eeee   ll   ll   aaaa    "An Atari 2600 VCS Emulator"
//    SSSS    tt   ee  ee  ll   ll      aa      
//       SS   tt   eeeeee  ll   ll   aaaaa   Copyright (c) 1995,1996,1997
//   SS  SS   tt   ee      ll   ll  aa  aa         Bradford W. Mott
//    SSSS     ttt  eeeee llll llll  aaaaa    
//
//============================================================================

/**
  This is a quick-and-dirty random number generator based on information
  in Chapter 7 of the Numerical Recipes in C book.  It's a simple linear
  congruential generator.

  @author  Bradford W. Mott
  @version $Id: Random.cxx,v 1.2 1997/05/17 19:00:07 bwmott Exp $
*/

#include <time.h>
#include "Random.hxx"

uLong Random::ourSeed = 0;
bool Random::ourSeeded = false;

//============================================================================
// Class member function to set the initial random seed
//============================================================================
void Random::seed(uLong value)
{
  ourSeed = value;
  ourSeeded = true;
}

//============================================================================
// Construct a random object
//============================================================================
Random::Random()
{
  // If we haven't been seeded then seed ourself
  if(!ourSeeded)
  {
    ourSeed = (uLong)time(0);
    ourSeeded = true;
  }

  myValue = ourSeed;
  ourSeed = ((ourSeed * 2416 + 374441) % 1771875);
}
 
//============================================================================
// Answer the next pseudo-random number
//============================================================================
inline uLong Random::next()
{
  return (myValue = (myValue * 2416 + 374441) % 1771875);
}

//============================================================================
// Answer a random uByte
//============================================================================
Random::operator uByte()
{
  return (uByte)next();
}
    
//============================================================================
// Answer a random Byte
//============================================================================
Random::operator Byte()
{
  return (Byte)next();
}

//============================================================================
// Answer a random uWord
//============================================================================
Random::operator uWord()
{
  return (uWord)next();
}
    
//============================================================================
// Answer a random Word
//============================================================================
Random::operator Word()
{
  return (Word)next();
}

//============================================================================
// Answer a random uLong
//============================================================================
Random::operator uLong()
{
  return (uLong)next();
}
    
//============================================================================
// Answer a random Long
//============================================================================
Random::operator Long()
{
  return (Long)next();
}