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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>Random123-1.09: Random123: a Library of Counter-Based Random Number Generators</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javaScript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css"/>
</head>
<body onload='searchBox.OnSelectItem(0);'>
<div class="tabs"><ul class="tablist"><li style="padding-left: 1.5em; font-weight: bold">Random123-1.09 Documentation</li></ul></div>
<!-- Generated by Doxygen 1.7.1 -->
<script type="text/javascript"><!--
var searchBox = new SearchBox("searchBox", "search",false,'Search');
--></script>
<div class="navigation" id="top">
<div class="tabs">
<ul class="tablist">
<li class="current"><a href="index.html"><span>Main Page</span></a></li>
<li><a href="pages.html"><span>Related Pages</span></a></li>
<li><a href="modules.html"><span>Modules</span></a></li>
<li><a href="namespaces.html"><span>Namespaces</span></a></li>
<li><a href="annotated.html"><span>Classes</span></a></li>
<li><a href="files.html"><span>Files</span></a></li>
<li id="searchli">
<div id="MSearchBox" class="MSearchBoxInactive">
<span class="left">
<img id="MSearchSelect" src="search/mag_sel.png"
onmouseover="return searchBox.OnSearchSelectShow()"
onmouseout="return searchBox.OnSearchSelectHide()"
alt=""/>
<input type="text" id="MSearchField" value="Search" accesskey="S"
onfocus="searchBox.OnSearchFieldFocus(true)"
onblur="searchBox.OnSearchFieldFocus(false)"
onkeyup="searchBox.OnSearchFieldChange(event)"/>
</span><span class="right">
<a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
</span>
</div>
</li>
</ul>
</div>
</div>
<div class="header">
<div class="headertitle">
<h1>Random123: a Library of Counter-Based Random Number Generators </h1> </div>
</div>
<div class="contents">
<p>The Random123 library is a collection of counter-based random number generators (<a class="el" href="CBRNG.html">CBRNGs</a>) for CPUs (C and C++) and GPUs (CUDA and OpenCL), as described in <a href="http://dl.acm.org/citation.cfm?doid=2063405"><em>Parallel Random Numbers: As Easy as 1, 2, 3</em>, Salmon, Moraes, Dror & Shaw, SC11, Seattle, Washington, USA, 2011, ACM </a>. They are intended for use in statistical applications and Monte Carlo simulation and have passed all of the rigorous SmallCrush, Crush and BigCrush tests in the <a href="http://www.iro.umontreal.ca/~simardr/testu01/tu01.html">extensive TestU01 suite</a> of statistical tests for random number generators. They are <b>not</b> suitable for use in cryptography or security even though they are constructed using principles drawn from cryptography.</p>
<p>CBRNGs are as fast as, or faster than conventional RNGs, much easier to parallelize, use minimal memory/cache resources, and require very little code. On modern architectures, the Random123 CBRNGs require a few cycles per byte of random data returned and return random data in convenient sizes (arrays of two or four elements, each element is an unsigned integer of 32 or 64 bits. The range of random numbers is the full representable range of the 32 or 64 bit unsigned integer) The <code><Random123/u01.h></code> header contains utility functions to convert 32- and 64-bit unsigned integers to open or closed ranges of single or double precision floating point numbers.</p>
<p>The Random123 library was written by John Salmon and Mark Moraes. It is available from <a href="http://deshawresearch.com/resources_random123.html">http://deshawresearch.com/resources_random123.html.</a> Please see the <a class="el" href="LICENSE.html">license</a> for terms and conditions. Please send feedback, including bug reports, suggestions, patches, etc. to <a href="mailto:random123@deshawresearch.com">random123@deshawresearch.com</a>.</p>
<h2><a class="anchor" id="overview"></a>
Overview</h2>
<p>Unlike conventional RNGs, counter-based RNGs are <b>stateless</b> functions (or function classes i.e. functors) whose arguments are a <em>counter</em>, and a <em>key</em> and returns a result of the same type as the counter.</p>
<p>result = CBRNGname(counter, key)</p>
<p>The returned result is a deterministic function of the key and counter, i.e. a unique (counter, key) tuple will always produce the same result. The result is highly sensitive to small changes in the inputs, so that the sequence of values produced by simply incrementing the counter (or key) is effectively indistinguishable from a sequence of samples of a uniformly distributed random variable.</p>
<p>For all the CBRNGs in the Random123 library, the result and counter are the same type, specifically an array of <em>N</em> words, where words have a width of <em>W</em> bits, encapsulated in <a class="el" href="group__arrayNxW.html">r123arrayNxW</a> structs, or equivalently, for C++, in the <a class="el" href="namespacer123.html#acc1b0ed919ef806de26f5ff5b934b313">ArrayNxW</a> typedefs in the <a class="el" href="namespacer123.html">r123</a> namespace. Keys are usually also arrayMxW types, but sometimes M is a different size than the counter N (e.g. Philox keys are half the number of elements as the counter, Threefry and ARS are the same number, AES uses an opaque key type rather than an array) The N random numbers returned in <code>result.v</code>[] are unsigned integers of width W (32 or 64), and the range of the random numbers is the full range of the unsigned integer of that width (i.e. 0 to 2^W-1)</p>
<p>In C++, all public names (classes, structs, typedefs, etc) are in the <code><a class="el" href="namespacer123.html">r123</a></code> namespace. In C, the public names (functions, enums, structs, typedefs) begin either with <code>r123</code> or with one of the RNG family names, e.g., <code>threefry</code>, <code>philox</code>, <code>ars</code>, <code>aesni</code>. The RNG functions themselves have names like <code>philox4x32</code>. C++ class names are capitalized, e.g., <code>Threefry4x32</code>.</p>
<h2><a class="anchor" id="families"></a>
The different families of Random123 generators</h2>
<p>Several families of CBRNGs are available in this version of the library: </p>
<ul>
<li>
<a class="el" href="group__ThreefryNxW.html">Threefry</a> is a <b>non-cryptographic</b> adaptation of the Threefish block cipher from the <a href="http://www.skein-hash.info/">Skein Hash Function</a>. See <a class="el" href="group__ThreefryNxW.html#ga1c32939b65f84966c93677f4382ea36d">r123::Threefry2x32</a>, <a class="el" href="group__ThreefryNxW.html#gacb09a2dcfb7389769f0c58f45f132aaa">r123::Threefry4x32</a>, <a class="el" href="group__ThreefryNxW.html#ga2b54dd1b0d20f09239be5f8757f1f3db">r123::Threefry2x64</a>, <a class="el" href="group__ThreefryNxW.html#gae17c98bddf067365508ed0717f865e8b">r123::Threefry4x64</a>. </li>
<li>
<a class="el" href="group__PhiloxNxW.html">Philox</a> uses a Feistel network and integer multiplication. See <a class="el" href="group__PhiloxNxW.html#ga81659a3ee5a1ca9e2e85c5d725a1ea4f">r123::Philox2x32</a>, <a class="el" href="group__PhiloxNxW.html#gaafd54060af05012db410034e3c0ecdc4">r123::Philox4x32</a>, <a class="el" href="group__PhiloxNxW.html#ga616a669079ac25119353416c14d46426">r123::Philox2x64</a>, <a class="el" href="group__PhiloxNxW.html#ga7776f4d481b7c0ac00db70272a1c77f0">r123::Philox4x64</a>. The Nx64 forms are only available on hardware that supports 64-bit multiplication producing a 128-bit result. </li>
<li>
<a class="el" href="group__AESNI.html">AESNI</a> uses the Advanced Encryption Standard (AES) New Instruction, available on certain modern x86 processors (some models of Intel Westmere and Sandy Bridge, and AMD Interlagos, as of 2011). AESNI CBRNGs can operate on four 32bit words (internally converting them to the 128bit SSE type needed by the AES-NI instructions, or on a single m128i "word", which holds the SSE type. See <a class="el" href="structr123_1_1AESNI4x32.html">r123::AESNI4x32</a>, <a class="el" href="structr123_1_1AESNI1xm128i.html">r123::AESNI1xm128i</a>. </li>
<li>
<a class="el" href="group__AESNI.html">ARS</a> (Advanced Randomization System) is a <b>non-cryptographic</b> simplification of <a class="el" href="group__AESNI.html">AESNI</a>. See <a class="el" href="structr123_1_1ARS4x32__R.html">r123::ARS4x32_R</a>, <a class="el" href="structr123_1_1ARS1xm128i__R.html">r123::ARS1xm128i_R</a>. </li>
</ul>
<h2><a class="anchor" id="install"></a>
Installation and Testing</h2>
<p>The Random123 library is implemented entirely in header files. Thus, there is nothing to compile before using it and nothing to link after you have <code>#include</code>d it in your source files. Simply direct your C or C++ compiler to find the header files in the <code>include/</code> directory that was unpacked from the distribution tar file and use the Random123 header files, types and functions in your application.</p>
<p>In addition to the <code>include/</code> files which implement the library the distribution also contains an <code>examples/</code> directory. Users are <b> STRONGLY ADVISED </b> to compile and run the tests in examples/ before using Random123 in an application (see <code> <a class="el" href="ExamplesREADME.html">examples/README</a></code>). Do not use the library if any tests fail. (It is not a failure for a test to report that it cannot run because of missing hardware capabilities like 64bit multiply, SSE, AES-NI or compiler capabilities)</p>
<h2><a class="anchor" id="usage"></a>
Usage</h2>
<h3><a class="anchor" id="CxxAPI"></a>
C++ API</h3>
<p>A typical C++ use case might look like:</p>
<div class="fragment"><pre class="fragment"><span class="preprocessor">#include <<a class="code" href="philox_8h.html">Random123/philox.h</a>></span>
<span class="keyword">typedef</span> <a class="code" href="structr123_1_1Philox4x32__R.html">r123::Philox4x32</a> RNG;
RNG rng;
RNG::ctr_type c={{}};
RNG::ukey_type uk={{}};
uk[0] = ???; <span class="comment">// some user_supplied_seed</span>
RNG::key_type k=uk;
<span class="keywordflow">for</span>(...){
c[0] = ???; <span class="comment">// some loop-dependent application variable </span>
c[1] = ???; <span class="comment">// another loop-dependent application variable </span>
RNG::ctr_type r = rng(c, k);
<span class="comment">// use the random values in r for some operation related to</span>
<span class="comment">// this iteration on objectid</span>
}
</pre></div><p>On each iteration,<code>r</code> contains an array of 4 32-bit random values that will not be repeated by any other call to <code>rng</code> as long as <code>c</code> and <code>k</code> are not reused.</p>
<p>In the example above, we use the <a class="el" href="group__PhiloxNxW.html#gaafd54060af05012db410034e3c0ecdc4">r123::Philox4x32</a>, but any of the other <a class="el" href="CBRNG.html">CBRNGs</a> would serve equally well. Also note that for most CBRNGs, the ukey_type and the key_type are identical; the code could just as well ignore the ukey_type and directly construct the key_type. However, for the <a class="el" href="group__AESNI.html">AESNI</a> CBRNGs, the key_type is opaque, and must be constructed from a ukey_type, as shown.</p>
<h3><a class="anchor" id="Capi"></a>
The C API</h3>
<p>In C, the example above could be written as: </p>
<div class="fragment"><pre class="fragment"><span class="preprocessor">#include <<a class="code" href="philox_8h.html">Random123/philox.h</a>></span>
<a class="code" href="structr123array4x32.html">philox4x32_ctr_t</a> c={{}};
<a class="code" href="structr123array2x32.html">philox4x32_ukey_t</a> uk={{}};
uk.<a class="code" href="structr123array2x32.html#a65524bf06568073021117ef196d6b45f">v</a>[0] = user_supplied_seed;
<a class="code" href="structr123array2x32.html">philox4x32_key_t</a> k = <a class="code" href="philox_8h.html#a5a012bb440c039eda46802b447c31851">philox4x32keyinit</a>(uk);
<span class="keywordflow">for</span>(...){
c.<a class="code" href="structr123array4x32.html#ac8e6785120a3031b211fc8aa7d03d83f">v</a>[0] = ???; <span class="comment">/* some loop-dependent application variable */</span>
c.<a class="code" href="structr123array4x32.html#ac8e6785120a3031b211fc8aa7d03d83f">v</a>[1] = ???; <span class="comment">/* another loop-dependent application variable */</span>
<a class="code" href="structr123array4x32.html">philox4x32_ctr_t</a> r = <a class="code" href="philox_8h.html#a432a3df828dd51acd0b7ec2fee1d4d7e">philox4x32</a>(c, k);
}
</pre></div><p>In C, access to the contents of the counter and key is through the fixed-size array member <code>v</code>.</p>
<h2><a class="anchor" id="cuda"></a>
The CUDA platform</h2>
<p>All relevant functions in the C and C++ APIs for Random123 are declared as CUDA device functions if they are included in a CUDA kernel source file and compiled with a CUDA compiler (nvcc). They can be used exactly as described/documented for regular C or C++ programs. Note that CUDA device functions and host functions share the same namespace, so it is not currently possible to use Random123 functions in both the host portion and the device portion of the same .cu source file. To work around this, you must compile Random123-using host code in a separate .c source file from your .cu device-resident code. The Nx32 forms are faster than the Nx64 variants on current (2011) 32-bit GPU architectures.</p>
<p>It has been reported that Random123 uses 16 bytes of static memory per thread. This is undesirable and not intentional, but we do not have a workaround other than to suggest adjusting memory allocation accordingly.</p>
<p>The pi_cuda.cu and pi_cudapp.cu examples illustrate the use of CUDA.</p>
<h2><a class="anchor" id="opencl"></a>
The OpenCL platform</h2>
<p>The functions in the Random123 C API can all be used in OpenCL kernels, just as in regular C functions. As with CUDA, the Nx32 forms are faster than the Nx64 variants on current (2011) 32-bit GPU architectures.</p>
<p>The pi_opencl.c and pi_opencl_kernel.ocl examples illustrate the use of OpenCL.</p>
<h2><a class="anchor" id="cplusplus0x"></a>
C++0X <random> interface</h2>
<p>In addition to the stateless ("pure/functional") C++ API above, the Random123 package includes two C++ classes that leverage the C++0X <random> API.</p>
<ul>
<li>
<a class="el" href="classr123_1_1MicroURNG.html">r123::MicroURNG</a> provides an adapter class that provides a more conventional interface compatible with the C++0X URNG (uniform random number generator) API; the MicroURNG adapter can be used with C++0x random number distributions and is fast/lightweight enough that a new MicroURNG can be instantiated with a unique key,counter tuple and used for each call to a distribution, there is little or no overhead to creating billions of unique MicroURNGs. This adapter retains one of the key advantages of CBRNGs -- complete application control over the RNG state. </li>
<li>
<a class="el" href="structr123_1_1Engine.html">r123::Engine</a> provides the C++0x Random Engine API. This can also be used with any of the C++0X random distributions, but sacrifices the application control over RNG state that is a defining characteristic of CBRNGs. </li>
</ul>
<h2><a class="anchor" id="gsl"></a>
The GNU Scientific Library (GSL) interface</h2>
<p>In addition to the stateless ("pure/functional") C API above, the Random123 package includes two C adapter interfaces to the <a href="http://www.gnu.org/s/gsl/">GNU Scientific Library (GSL).</a></p>
<ul>
<li>
The <a class="el" href="gsl__microrng_8h.html#a21c7bb64a536a1704c6dc96856b78297">GSL_MICRORNG</a> macro allows the application to define a GSL random number generator. It can be used with GSL random distributions but still provides the application with complete control over the RNG state (it is analogous to the MicroURNG class, in that it uses shorter periods, and is intended to be instantiated in large numbers for a few calls to the random distribution). </li>
<li>
The <a class="el" href="gsl__cbrng_8h.html#af561a004eef8e93cdfd6b255a8a1eb75">GSL_CBRNG</a> macro allows the application to create a GSL RNG with a completely conventional interface, sacrificing application control over the internal RNG state. </li>
</ul>
<h2><a class="anchor" id="u01"></a>
Generating uniformly distributed and Gaussian distributed floats and doubles</h2>
<p>The Random123 library provides generators for uniformly distributed random <b>integers</b>. Often, applications want random <b>real</b> values or samples from other distributions. The general problem of generating samples from arbitrary distributions is beyond the scope of the Random123 library. One can, of course, use GSL or MicroURNG and the distributions in the C++11 <random> library, but a few simple cases are common enough that all that extra machinery seems like overkill. We have included code in the examples/ directory which developers may find useful.</p>
<ul>
<li>
examples/uniform.hpp - C++ functions that convert random integers to random, uniformly distributed floating point values. </li>
<li>
examples/u01fixedpt.h - C functions that convert random integers to random, uniformly distributed, equi-spaced, i.e., fixed point, values. </li>
<li>
examples/ua.hpp - C++11 functions that convert r123arrays of uniformly distributed integers into std::arrays of uniformly distributed floating point types. The return type is std::array because it is far easier, with template logic, to return a std::array of the correct size than an r123array of the correct size. </li>
<li>
examples/boxmuller.hpp - C++ functions that take two uniformly distributed integers (32 or 64 bit) and return a pair of Gaussian distributed floats or doubles. </li>
</ul>
<p>The Box-Muller method of generating Gaussian random variables is particularly well suited to Random123 because it deterministically consumes exactly two uniform randoms to generate exactly two gaussian randoms. It uses math library functions: sincos, log and sqrt which may be slow on some platforms, but which are surprisingly fast on others. Notably, on GPUs, the lack of branching in the Box-Muller method and hardware support for math functions overcomes the transcendental function overhead, making it the fastest generator of Gaussians that we are aware of.</p>
<h3><a class="anchor" id="Examples"></a>
Tests and Benchmarks</h3>
<p>The <a class="el" href="ExamplesREADME.html">examples/</a> directory, contains tests, examples and benchmarks.</p>
<ul>
<li>
Unit tests for individual components and "known-answer-tests", which should be run to ensure that these RNGs build correctly on desired platforms. These help to provide assurance that the code is being compiled correctly. </li>
<li>
Complete, short programs estimate pi by counting the number of random points that fall inside a circle inscribed in a square, demonstrating the C, C++, AES, GSL, OpenCL, CUDA and C++0x APIs. </li>
<li>
Header files, including uniform.hpp, ufixed01.h, ua.hpp, and boxmuller.hpp containing code that users may find useful but that are outside the scope of the Random123 library itself. </li>
<li>
Some highly abstracted timing harnesses are provided which measure performance of a variety of generators in different programming environments. </li>
</ul>
<h2><a class="anchor" id="portability"></a>
Portability</h2>
<p>Although we have done our best to make Random123 portable and standards conforming, it is an unfortunate fact that there is no portable code. There is only code that has been ported. We have tested the Random123 library with the following infrastructure</p>
<ul>
<li>
Linux, gcc (multiple versions from 3.4.3 through 5.2), on x86_64. </li>
<li>
Linux, clang-2.9, 3.0, 3.1, 3.3 and 3.6 on x86_64. </li>
<li>
Linux, clang-3.0 and 3.1 with lib++ (2012-04-19 svn checkout) on x86_64. </li>
<li>
Linux, open64-4.2.4 on x86_64. </li>
<li>
Linux, Intel icc and icpc 12.0.2 on x86_64. </li>
<li>
Linux, OpenCL (NVIDIA SDK 4.0.17) on GTX480, M2090, GTX580 and GTX680 GPUs. </li>
<li>
Linux, OpenCL (AMD APP SDK 2.4 or 2.5), on x86_64 CPUs and Radeon HD6970 GPUs. </li>
<li>
Linux, OpenCL (Intel OpenCL 1.5), on x86_64 CPUs. </li>
<li>
Linux, NVIDIA CUDA 4.1.15, 4.2.6, 5.5.22 and 7.5.1. (NOTE: We recommend against the use of CUDA before 4.1) </li>
<li>
Linux, gcc-4.1.2 and 4.4.1 on x86. </li>
<li>
Solaris, both gcc-3.4.3 and Sun C/C++ 5.8, on x86_64. </li>
<li>
FreeBSD 8.2, gcc-4.2.1, on x86_64. </li>
<li>
MacOS X 5.8, gcc-4.0.1, on x86. </li>
<li>
MacOS X 5.8, llvm-2.9.1 on x86 (problems with catching C++ exceptions). </li>
<li>
Windows 7, Microsoft Visual Studio, version 10.0, Microsoft C/C++ compiler 16.00. </li>
</ul>
<p>Others have reported success on </p>
<ul>
<li>
MacOS, OpenCL on x86_64 CPUs </li>
<li>
Linux, gcc-4.7.2 on Powerpc64 (BlueGene/Q) </li>
<li>
Linux, Portland Group Compiler on Powerpc64 (BlueGene/Q) </li>
<li>
Linux, IBM xlc on Powerpc64 (BlueGene/Q) </li>
</ul>
<h2><a class="anchor" id="warnings"></a>
Warnings</h2>
<p>With some compilation options, the CUDA nvcc compiler warns about unreachable code in <a class="el" href="array_8h.html">array.h</a>. The compiler doesn't recognize that the code that is unreachable for some values of some macro parameters, is actually reachable for other values of the parameters. It is possible to disable that particular warning for a specific compilation unit by adding -Wcudafe --diag_suppress=111 to the compilation command line.</p>
<h2><a class="anchor" id="contributors"></a>
Contributors</h2>
<p>We welcome feedback to <a href="mailto:random123@deshawresearch.com">random123@deshawresearch.com</a> about ports to other environments.</p>
<p>We are grateful for contributions from the following users: </p>
<ul>
<li>
Geoffrey Irving and Gabriel Rockefeller - BlueGene/Q and powerpc ports </li>
<li>
Yan Zhou - MacOS and clang ports </li>
<li>
David Lawrie - allowing 64-bit philox to compile for both host and device with CUDA </li>
<li>
Bogdan Opanchuk - pointing out the inconsistent rotation constants in the implementation of threefry2xW in version 1.07 and earlier. </li>
</ul>
</div>
<!--- window showing the filter options -->
<div id="MSearchSelectWindow"
onmouseover="return searchBox.OnSearchSelectShow()"
onmouseout="return searchBox.OnSearchSelectHide()"
onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark"> </span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark"> </span>Classes</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark"> </span>Namespaces</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark"> </span>Files</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark"> </span>Functions</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(5)"><span class="SelectionMark"> </span>Variables</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(6)"><span class="SelectionMark"> </span>Typedefs</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(7)"><span class="SelectionMark"> </span>Enumerations</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(8)"><span class="SelectionMark"> </span>Enumerator</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(9)"><span class="SelectionMark"> </span>Friends</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(10)"><span class="SelectionMark"> </span>Defines</a></div>
<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="" frameborder="0"
name="MSearchResults" id="MSearchResults">
</iframe>
</div>
<hr class="footer"/><address class="footer"><small>Generated on Mon Mar 7 2016 18:34:00 for Random123-1.09 by
<a href="http://www.doxygen.org/index.html">
<img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.7.1 </small></address>
</body>
</html>
|
