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
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
<!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/philox.h Source File</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><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 class="current"><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 class="tabs2">
<ul class="tablist">
<li><a href="files.html"><span>File List</span></a></li>
<li><a href="globals.html"><span>File Members</span></a></li>
</ul>
</div>
<div class="header">
<div class="headertitle">
<h1>Random123/philox.h</h1> </div>
</div>
<div class="contents">
<a href="philox_8h.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 <span class="comment">/*</span>
<a name="l00002"></a>00002 <span class="comment">Copyright 2010-2011, D. E. Shaw Research.</span>
<a name="l00003"></a>00003 <span class="comment">All rights reserved.</span>
<a name="l00004"></a>00004 <span class="comment"></span>
<a name="l00005"></a>00005 <span class="comment">Redistribution and use in source and binary forms, with or without</span>
<a name="l00006"></a>00006 <span class="comment">modification, are permitted provided that the following conditions are</span>
<a name="l00007"></a>00007 <span class="comment">met:</span>
<a name="l00008"></a>00008 <span class="comment"></span>
<a name="l00009"></a>00009 <span class="comment">* Redistributions of source code must retain the above copyright</span>
<a name="l00010"></a>00010 <span class="comment"> notice, this list of conditions, and the following disclaimer.</span>
<a name="l00011"></a>00011 <span class="comment"></span>
<a name="l00012"></a>00012 <span class="comment">* Redistributions in binary form must reproduce the above copyright</span>
<a name="l00013"></a>00013 <span class="comment"> notice, this list of conditions, and the following disclaimer in the</span>
<a name="l00014"></a>00014 <span class="comment"> documentation and/or other materials provided with the distribution.</span>
<a name="l00015"></a>00015 <span class="comment"></span>
<a name="l00016"></a>00016 <span class="comment">* Neither the name of D. E. Shaw Research nor the names of its</span>
<a name="l00017"></a>00017 <span class="comment"> contributors may be used to endorse or promote products derived from</span>
<a name="l00018"></a>00018 <span class="comment"> this software without specific prior written permission.</span>
<a name="l00019"></a>00019 <span class="comment"></span>
<a name="l00020"></a>00020 <span class="comment">THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS</span>
<a name="l00021"></a>00021 <span class="comment">"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT</span>
<a name="l00022"></a>00022 <span class="comment">LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR</span>
<a name="l00023"></a>00023 <span class="comment">A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT</span>
<a name="l00024"></a>00024 <span class="comment">OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,</span>
<a name="l00025"></a>00025 <span class="comment">SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT</span>
<a name="l00026"></a>00026 <span class="comment">LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,</span>
<a name="l00027"></a>00027 <span class="comment">DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY</span>
<a name="l00028"></a>00028 <span class="comment">THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT</span>
<a name="l00029"></a>00029 <span class="comment">(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE</span>
<a name="l00030"></a>00030 <span class="comment">OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</span>
<a name="l00031"></a>00031 <span class="comment">*/</span>
<a name="l00032"></a>00032 <span class="preprocessor">#ifndef _philox_dot_h_</span>
<a name="l00033"></a>00033 <span class="preprocessor"></span><span class="preprocessor">#define _philox_dot_h_</span>
<a name="l00034"></a>00034 <span class="preprocessor"></span>
<a name="l00037"></a>00037 <span class="preprocessor">#include "<a class="code" href="compilerfeatures_8h.html">features/compilerfeatures.h</a>"</span>
<a name="l00038"></a>00038 <span class="preprocessor">#include "<a class="code" href="array_8h.html">array.h</a>"</span>
<a name="l00039"></a>00039
<a name="l00040"></a>00040
<a name="l00041"></a>00041 <span class="comment">/*</span>
<a name="l00042"></a>00042 <span class="comment">// Macros _Foo_tpl are code generation 'templates' They define</span>
<a name="l00043"></a>00043 <span class="comment">// inline functions with names obtained by mangling Foo and the</span>
<a name="l00044"></a>00044 <span class="comment">// macro arguments. E.g.,</span>
<a name="l00045"></a>00045 <span class="comment">// _mulhilo_tpl(32, uint32_t, uint64_t)</span>
<a name="l00046"></a>00046 <span class="comment">// expands to a definition of:</span>
<a name="l00047"></a>00047 <span class="comment">// mulhilo32(uint32_t, uint32_t, uint32_t *, uint32_t *)</span>
<a name="l00048"></a>00048 <span class="comment">// We then 'instantiate the template' to define</span>
<a name="l00049"></a>00049 <span class="comment">// several different functions, e.g.,</span>
<a name="l00050"></a>00050 <span class="comment">// mulhilo32</span>
<a name="l00051"></a>00051 <span class="comment">// mulhilo64</span>
<a name="l00052"></a>00052 <span class="comment">// These functions will be visible to user code, and may</span>
<a name="l00053"></a>00053 <span class="comment">// also be used later in subsequent templates and definitions.</span>
<a name="l00054"></a>00054 <span class="comment"></span>
<a name="l00055"></a>00055 <span class="comment">// A template for mulhilo using a temporary of twice the word-width.</span>
<a name="l00056"></a>00056 <span class="comment">// Gcc figures out that this can be reduced to a single 'mul' instruction,</span>
<a name="l00057"></a>00057 <span class="comment">// despite the apparent use of double-wide variables, shifts, etc. It's</span>
<a name="l00058"></a>00058 <span class="comment">// obviously not guaranteed that all compilers will be that smart, so</span>
<a name="l00059"></a>00059 <span class="comment">// other implementations might be preferable, e.g., using an intrinsic</span>
<a name="l00060"></a>00060 <span class="comment">// or an asm block. On the other hand, for 32-bit multiplies,</span>
<a name="l00061"></a>00061 <span class="comment">// this *is* perfectly standard C99 - any C99 compiler should </span>
<a name="l00062"></a>00062 <span class="comment">// understand it and produce correct code. For 64-bit multiplies,</span>
<a name="l00063"></a>00063 <span class="comment">// it's only usable if the compiler recognizes that it can do</span>
<a name="l00064"></a>00064 <span class="comment">// arithmetic on a 128-bit type. That happens to be true for gcc on</span>
<a name="l00065"></a>00065 <span class="comment">// x86-64, and powerpc64 but not much else.</span>
<a name="l00066"></a>00066 <span class="comment">*/</span>
<a name="l00067"></a>00067 <span class="preprocessor">#define _mulhilo_dword_tpl(W, Word, Dword) \</span>
<a name="l00068"></a>00068 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE Word mulhilo##W(Word a, Word b, Word* hip){ \</span>
<a name="l00069"></a>00069 <span class="preprocessor"> Dword product = ((Dword)a)*((Dword)b); \</span>
<a name="l00070"></a>00070 <span class="preprocessor"> *hip = product>>W; \</span>
<a name="l00071"></a>00071 <span class="preprocessor"> return (Word)product; \</span>
<a name="l00072"></a>00072 <span class="preprocessor">}</span>
<a name="l00073"></a>00073 <span class="preprocessor"></span>
<a name="l00074"></a>00074 <span class="comment">/*</span>
<a name="l00075"></a>00075 <span class="comment">// A template for mulhilo using gnu-style asm syntax.</span>
<a name="l00076"></a>00076 <span class="comment">// INSN can be "mulw", "mull" or "mulq". </span>
<a name="l00077"></a>00077 <span class="comment">// FIXME - porting to other architectures, we'll need still-more conditional</span>
<a name="l00078"></a>00078 <span class="comment">// branching here. Note that intrinsics are usually preferable.</span>
<a name="l00079"></a>00079 <span class="comment">*/</span>
<a name="l00080"></a>00080 <span class="preprocessor">#ifdef __powerpc__</span>
<a name="l00081"></a>00081 <span class="preprocessor"></span><span class="preprocessor">#define _mulhilo_asm_tpl(W, Word, INSN) \</span>
<a name="l00082"></a>00082 <span class="preprocessor">R123_STATIC_INLINE Word mulhilo##W(Word ax, Word b, Word *hip){ \</span>
<a name="l00083"></a>00083 <span class="preprocessor"> Word dx = 0; \</span>
<a name="l00084"></a>00084 <span class="preprocessor"> __asm__("\n\t" \</span>
<a name="l00085"></a>00085 <span class="preprocessor"> INSN " %0,%1,%2\n\t" \</span>
<a name="l00086"></a>00086 <span class="preprocessor"> : "=r"(dx) \</span>
<a name="l00087"></a>00087 <span class="preprocessor"> : "r"(b), "r"(ax) \</span>
<a name="l00088"></a>00088 <span class="preprocessor"> ); \</span>
<a name="l00089"></a>00089 <span class="preprocessor"> *hip = dx; \</span>
<a name="l00090"></a>00090 <span class="preprocessor"> return ax*b; \</span>
<a name="l00091"></a>00091 <span class="preprocessor">}</span>
<a name="l00092"></a>00092 <span class="preprocessor"></span><span class="preprocessor">#else</span>
<a name="l00093"></a>00093 <span class="preprocessor"></span><span class="preprocessor">#define _mulhilo_asm_tpl(W, Word, INSN) \</span>
<a name="l00094"></a>00094 <span class="preprocessor">R123_STATIC_INLINE Word mulhilo##W(Word ax, Word b, Word *hip){ \</span>
<a name="l00095"></a>00095 <span class="preprocessor"> Word dx; \</span>
<a name="l00096"></a>00096 <span class="preprocessor"> __asm__("\n\t" \</span>
<a name="l00097"></a>00097 <span class="preprocessor"> INSN " %2\n\t" \</span>
<a name="l00098"></a>00098 <span class="preprocessor"> : "=a"(ax), "=d"(dx) \</span>
<a name="l00099"></a>00099 <span class="preprocessor"> : "r"(b), "0"(ax) \</span>
<a name="l00100"></a>00100 <span class="preprocessor"> ); \</span>
<a name="l00101"></a>00101 <span class="preprocessor"> *hip = dx; \</span>
<a name="l00102"></a>00102 <span class="preprocessor"> return ax; \</span>
<a name="l00103"></a>00103 <span class="preprocessor">}</span>
<a name="l00104"></a>00104 <span class="preprocessor"></span><span class="preprocessor">#endif </span><span class="comment">/* __powerpc__ */</span>
<a name="l00105"></a>00105
<a name="l00106"></a>00106 <span class="comment">/*</span>
<a name="l00107"></a>00107 <span class="comment">// A template for mulhilo using MSVC-style intrinsics</span>
<a name="l00108"></a>00108 <span class="comment">// For example,_umul128 is an msvc intrinsic, c.f.</span>
<a name="l00109"></a>00109 <span class="comment">// http://msdn.microsoft.com/en-us/library/3dayytw9.aspx</span>
<a name="l00110"></a>00110 <span class="comment">*/</span>
<a name="l00111"></a>00111 <span class="preprocessor">#define _mulhilo_msvc_intrin_tpl(W, Word, INTRIN) \</span>
<a name="l00112"></a>00112 <span class="preprocessor">R123_STATIC_INLINE Word mulhilo##W(Word a, Word b, Word* hip){ \</span>
<a name="l00113"></a>00113 <span class="preprocessor"> return INTRIN(a, b, hip); \</span>
<a name="l00114"></a>00114 <span class="preprocessor">}</span>
<a name="l00115"></a>00115 <span class="preprocessor"></span>
<a name="l00116"></a>00116 <span class="comment">/* N.B. This really should be called _mulhilo_mulhi_intrin. It just</span>
<a name="l00117"></a>00117 <span class="comment"> happens that CUDA was the first time we used the idiom. */</span>
<a name="l00118"></a>00118 <span class="preprocessor">#define _mulhilo_cuda_intrin_tpl(W, Word, INTRIN) \</span>
<a name="l00119"></a>00119 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE Word mulhilo##W(Word a, Word b, Word* hip){ \</span>
<a name="l00120"></a>00120 <span class="preprocessor"> *hip = INTRIN(a, b); \</span>
<a name="l00121"></a>00121 <span class="preprocessor"> return a*b; \</span>
<a name="l00122"></a>00122 <span class="preprocessor">}</span>
<a name="l00123"></a>00123 <span class="preprocessor"></span>
<a name="l00124"></a>00124 <span class="comment">/*</span>
<a name="l00125"></a>00125 <span class="comment">// A template for mulhilo using only word-size operations and</span>
<a name="l00126"></a>00126 <span class="comment">// C99 operators (no adc, no mulhi). It</span>
<a name="l00127"></a>00127 <span class="comment">// requires four multiplies and a dozen or so shifts, adds</span>
<a name="l00128"></a>00128 <span class="comment">// and tests. It's not clear what this is good for, other than</span>
<a name="l00129"></a>00129 <span class="comment">// completeness. On 32-bit platforms, it could be used to</span>
<a name="l00130"></a>00130 <span class="comment">// implement philoxNx64, but on such platforms both the philoxNx32</span>
<a name="l00131"></a>00131 <span class="comment">// and the threefryNx64 cbrngs are going to have much better</span>
<a name="l00132"></a>00132 <span class="comment">// performance. It is enabled below by R123_USE_MULHILO64_C99,</span>
<a name="l00133"></a>00133 <span class="comment">// but that is currently (Sep 2011) not set by any of the</span>
<a name="l00134"></a>00134 <span class="comment">// features/XXfeatures.h headers. It can, of course, be</span>
<a name="l00135"></a>00135 <span class="comment">// set with a compile-time -D option.</span>
<a name="l00136"></a>00136 <span class="comment">*/</span>
<a name="l00137"></a>00137 <span class="preprocessor">#define _mulhilo_c99_tpl(W, Word) \</span>
<a name="l00138"></a>00138 <span class="preprocessor">R123_STATIC_INLINE Word mulhilo##W(Word a, Word b, Word *hip){ \</span>
<a name="l00139"></a>00139 <span class="preprocessor"> const unsigned WHALF = W/2; \</span>
<a name="l00140"></a>00140 <span class="preprocessor"> const Word LOMASK = ((((Word)1)<<WHALF)-1); \</span>
<a name="l00141"></a>00141 <span class="preprocessor"> Word lo = a*b; </span><span class="comment">/* full low multiply */</span> \
<a name="l00142"></a>00142 Word ahi = a>>WHALF; \
<a name="l00143"></a>00143 Word alo = a& LOMASK; \
<a name="l00144"></a>00144 Word bhi = b>>WHALF; \
<a name="l00145"></a>00145 Word blo = b& LOMASK; \
<a name="l00146"></a>00146 \
<a name="l00147"></a>00147 Word ahbl = ahi*blo; \
<a name="l00148"></a>00148 Word albh = alo*bhi; \
<a name="l00149"></a>00149 \
<a name="l00150"></a>00150 Word ahbl_albh = ((ahbl&LOMASK) + (albh&LOMASK)); \
<a name="l00151"></a>00151 Word hi = ahi*bhi + (ahbl>>WHALF) + (albh>>WHALF); \
<a name="l00152"></a>00152 hi += ahbl_albh >> WHALF; <span class="comment">/* carry from the sum of lo(ahbl) + lo(albh) ) */</span> \
<a name="l00153"></a>00153 <span class="comment">/* carry from the sum with alo*blo */</span> \
<a name="l00154"></a>00154 hi += ((lo >> WHALF) < (ahbl_albh&LOMASK)); \
<a name="l00155"></a>00155 *hip = hi; \
<a name="l00156"></a>00156 return lo; \
<a name="l00157"></a>00157 }
<a name="l00158"></a>00158
<a name="l00159"></a>00159 <span class="comment">/*</span>
<a name="l00160"></a>00160 <span class="comment">// A template for mulhilo on a platform that can't do it</span>
<a name="l00161"></a>00161 <span class="comment">// We could put a C version here, but is it better to run *VERY*</span>
<a name="l00162"></a>00162 <span class="comment">// slowly or to just stop and force the user to find another CBRNG?</span>
<a name="l00163"></a>00163 <span class="comment">*/</span>
<a name="l00164"></a>00164 <span class="preprocessor">#define _mulhilo_fail_tpl(W, Word) \</span>
<a name="l00165"></a>00165 <span class="preprocessor">R123_STATIC_INLINE Word mulhilo##W(Word a, Word b, Word *hip){ \</span>
<a name="l00166"></a>00166 <span class="preprocessor"> R123_STATIC_ASSERT(0, "mulhilo" #W " is not implemented on this machine\n"); \</span>
<a name="l00167"></a>00167 <span class="preprocessor">}</span>
<a name="l00168"></a>00168 <span class="preprocessor"></span>
<a name="l00169"></a>00169 <span class="comment">/*</span>
<a name="l00170"></a>00170 <span class="comment">// N.B. There's an MSVC intrinsic called _emul,</span>
<a name="l00171"></a>00171 <span class="comment">// which *might* compile into better code than</span>
<a name="l00172"></a>00172 <span class="comment">// _mulhilo_dword_tpl </span>
<a name="l00173"></a>00173 <span class="comment">*/</span>
<a name="l00174"></a>00174 <span class="preprocessor">#if R123_USE_MULHILO32_ASM</span>
<a name="l00175"></a>00175 <span class="preprocessor"></span><span class="preprocessor">#ifdef __powerpc__</span>
<a name="l00176"></a>00176 <span class="preprocessor"></span>_mulhilo_asm_tpl(32, uint32_t, <span class="stringliteral">"mulhwu"</span>)
<a name="l00177"></a>00177 <span class="preprocessor">#else</span>
<a name="l00178"></a>00178 <span class="preprocessor"></span>_mulhilo_asm_tpl(32, uint32_t, <span class="stringliteral">"mull"</span>)
<a name="l00179"></a>00179 <span class="preprocessor">#endif </span><span class="comment">/* __powerpc__ */</span>
<a name="l00180"></a>00180 <span class="preprocessor">#else</span>
<a name="l00181"></a>00181 <span class="preprocessor"></span>_mulhilo_dword_tpl(32, uint32_t, uint64_t)
<a name="l00182"></a>00182 <span class="preprocessor">#endif</span>
<a name="l00183"></a>00183 <span class="preprocessor"></span>
<a name="l00184"></a>00184 <span class="preprocessor">#if R123_USE_PHILOX_64BIT</span>
<a name="l00185"></a>00185 <span class="preprocessor"></span><span class="preprocessor">#if R123_USE_MULHILO64_ASM</span>
<a name="l00186"></a>00186 <span class="preprocessor"></span><span class="preprocessor">#ifdef __powerpc64__</span>
<a name="l00187"></a>00187 <span class="preprocessor"></span>_mulhilo_asm_tpl(64, uint64_t, <span class="stringliteral">"mulhdu"</span>)
<a name="l00188"></a>00188 <span class="preprocessor">#else</span>
<a name="l00189"></a>00189 <span class="preprocessor"></span>_mulhilo_asm_tpl(64, uint64_t, <span class="stringliteral">"mulq"</span>)
<a name="l00190"></a>00190 <span class="preprocessor">#endif </span><span class="comment">/* __powerpc64__ */</span>
<a name="l00191"></a>00191 <span class="preprocessor">#elif R123_USE_MULHILO64_MSVC_INTRIN</span>
<a name="l00192"></a>00192 <span class="preprocessor"></span>_mulhilo_msvc_intrin_tpl(64, uint64_t, _umul128)
<a name="l00193"></a>00193 <span class="preprocessor">#elif R123_USE_MULHILO64_CUDA_INTRIN</span>
<a name="l00194"></a>00194 <span class="preprocessor"></span>_mulhilo_cuda_intrin_tpl(64, uint64_t, __umul64hi)
<a name="l00195"></a>00195 <span class="preprocessor">#elif R123_USE_MULHILO64_OPENCL_INTRIN</span>
<a name="l00196"></a>00196 <span class="preprocessor"></span>_mulhilo_cuda_intrin_tpl(64, uint64_t, mul_hi)
<a name="l00197"></a>00197 <span class="preprocessor">#elif R123_USE_MULHILO64_MULHI_INTRIN</span>
<a name="l00198"></a>00198 <span class="preprocessor"></span>_mulhilo_cuda_intrin_tpl(64, uint64_t, R123_MULHILO64_MULHI_INTRIN)
<a name="l00199"></a>00199 <span class="preprocessor">#elif R123_USE_GNU_UINT128</span>
<a name="l00200"></a>00200 <span class="preprocessor"></span>_mulhilo_dword_tpl(64, uint64_t, __uint128_t)
<a name="l00201"></a>00201 <span class="preprocessor">#elif R123_USE_MULHILO64_C99</span>
<a name="l00202"></a>00202 <span class="preprocessor"></span>_mulhilo_c99_tpl(64, uint64_t)
<a name="l00203"></a>00203 <span class="preprocessor">#else</span>
<a name="l00204"></a>00204 <span class="preprocessor"></span>_mulhilo_fail_tpl(64, uint64_t)
<a name="l00205"></a>00205 <span class="preprocessor">#endif</span>
<a name="l00206"></a>00206 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00207"></a>00207 <span class="preprocessor"></span>
<a name="l00208"></a>00208 <span class="comment">/*</span>
<a name="l00209"></a>00209 <span class="comment">// The multipliers and Weyl constants are "hard coded".</span>
<a name="l00210"></a>00210 <span class="comment">// To change them, you can #define them with different</span>
<a name="l00211"></a>00211 <span class="comment">// values before #include-ing this file. </span>
<a name="l00212"></a>00212 <span class="comment">// This isn't terribly elegant, but it works for C as</span>
<a name="l00213"></a>00213 <span class="comment">// well as C++. A nice C++-only solution would be to</span>
<a name="l00214"></a>00214 <span class="comment">// use template parameters in the style of <random></span>
<a name="l00215"></a>00215 <span class="comment">*/</span>
<a name="l00216"></a>00216 <span class="preprocessor">#ifndef PHILOX_M2x64_0</span>
<a name="l00217"></a>00217 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_M2x64_0 R123_64BIT(0xD2B74407B1CE6E93)</span>
<a name="l00218"></a>00218 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00219"></a>00219 <span class="preprocessor"></span>
<a name="l00220"></a>00220 <span class="preprocessor">#ifndef PHILOX_M4x64_0</span>
<a name="l00221"></a>00221 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_M4x64_0 R123_64BIT(0xD2E7470EE14C6C93)</span>
<a name="l00222"></a>00222 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00223"></a>00223 <span class="preprocessor"></span>
<a name="l00224"></a>00224 <span class="preprocessor">#ifndef PHILOX_M4x64_1</span>
<a name="l00225"></a>00225 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_M4x64_1 R123_64BIT(0xCA5A826395121157)</span>
<a name="l00226"></a>00226 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00227"></a>00227 <span class="preprocessor"></span>
<a name="l00228"></a>00228 <span class="preprocessor">#ifndef PHILOX_M2x32_0</span>
<a name="l00229"></a>00229 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_M2x32_0 ((uint32_t)0xd256d193)</span>
<a name="l00230"></a>00230 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00231"></a>00231 <span class="preprocessor"></span>
<a name="l00232"></a>00232 <span class="preprocessor">#ifndef PHILOX_M4x32_0</span>
<a name="l00233"></a>00233 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_M4x32_0 ((uint32_t)0xD2511F53)</span>
<a name="l00234"></a>00234 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00235"></a>00235 <span class="preprocessor"></span><span class="preprocessor">#ifndef PHILOX_M4x32_1</span>
<a name="l00236"></a>00236 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_M4x32_1 ((uint32_t)0xCD9E8D57)</span>
<a name="l00237"></a>00237 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00238"></a>00238 <span class="preprocessor"></span>
<a name="l00239"></a>00239 <span class="preprocessor">#ifndef PHILOX_W64_0</span>
<a name="l00240"></a>00240 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_W64_0 R123_64BIT(0x9E3779B97F4A7C15) </span><span class="comment">/* golden ratio */</span>
<a name="l00241"></a>00241 <span class="preprocessor">#endif</span>
<a name="l00242"></a>00242 <span class="preprocessor"></span><span class="preprocessor">#ifndef PHILOX_W64_1</span>
<a name="l00243"></a>00243 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_W64_1 R123_64BIT(0xBB67AE8584CAA73B) </span><span class="comment">/* sqrt(3)-1 */</span>
<a name="l00244"></a>00244 <span class="preprocessor">#endif</span>
<a name="l00245"></a>00245 <span class="preprocessor"></span>
<a name="l00246"></a>00246 <span class="preprocessor">#ifndef PHILOX_W32_0</span>
<a name="l00247"></a>00247 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_W32_0 ((uint32_t)0x9E3779B9)</span>
<a name="l00248"></a>00248 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00249"></a>00249 <span class="preprocessor"></span><span class="preprocessor">#ifndef PHILOX_W32_1</span>
<a name="l00250"></a>00250 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX_W32_1 ((uint32_t)0xBB67AE85)</span>
<a name="l00251"></a>00251 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00252"></a>00252 <span class="preprocessor"></span>
<a name="l00253"></a>00253 <span class="preprocessor">#ifndef PHILOX2x32_DEFAULT_ROUNDS</span>
<a name="l00254"></a>00254 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX2x32_DEFAULT_ROUNDS 10</span>
<a name="l00255"></a>00255 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00256"></a>00256 <span class="preprocessor"></span>
<a name="l00257"></a>00257 <span class="preprocessor">#ifndef PHILOX2x64_DEFAULT_ROUNDS</span>
<a name="l00258"></a>00258 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX2x64_DEFAULT_ROUNDS 10</span>
<a name="l00259"></a>00259 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00260"></a>00260 <span class="preprocessor"></span>
<a name="l00261"></a>00261 <span class="preprocessor">#ifndef PHILOX4x32_DEFAULT_ROUNDS</span>
<a name="l00262"></a>00262 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX4x32_DEFAULT_ROUNDS 10</span>
<a name="l00263"></a>00263 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00264"></a>00264 <span class="preprocessor"></span>
<a name="l00265"></a>00265 <span class="preprocessor">#ifndef PHILOX4x64_DEFAULT_ROUNDS</span>
<a name="l00266"></a>00266 <span class="preprocessor"></span><span class="preprocessor">#define PHILOX4x64_DEFAULT_ROUNDS 10</span>
<a name="l00267"></a>00267 <span class="preprocessor"></span><span class="preprocessor">#endif</span>
<a name="l00268"></a>00268 <span class="preprocessor"></span>
<a name="l00269"></a>00269 <span class="comment">/* The ignored fourth argument allows us to instantiate the</span>
<a name="l00270"></a>00270 <span class="comment"> same macro regardless of N. */</span>
<a name="l00271"></a>00271 <span class="preprocessor">#define _philox2xWround_tpl(W, T) \</span>
<a name="l00272"></a>00272 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE R123_FORCE_INLINE(struct r123array2x##W _philox2x##W##round(struct r123array2x##W ctr, struct r123array1x##W key)); \</span>
<a name="l00273"></a>00273 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE struct r123array2x##W _philox2x##W##round(struct r123array2x##W ctr, struct r123array1x##W key){ \</span>
<a name="l00274"></a>00274 <span class="preprocessor"> T hi; \</span>
<a name="l00275"></a>00275 <span class="preprocessor"> T lo = mulhilo##W(PHILOX_M2x##W##_0, ctr.v[0], &hi); \</span>
<a name="l00276"></a>00276 <span class="preprocessor"> struct r123array2x##W out = {{hi^key.v[0]^ctr.v[1], lo}}; \</span>
<a name="l00277"></a>00277 <span class="preprocessor"> return out; \</span>
<a name="l00278"></a>00278 <span class="preprocessor">}</span>
<a name="l00279"></a>00279 <span class="preprocessor"></span><span class="preprocessor">#define _philox2xWbumpkey_tpl(W) \</span>
<a name="l00280"></a>00280 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE struct r123array1x##W _philox2x##W##bumpkey( struct r123array1x##W key) { \</span>
<a name="l00281"></a>00281 <span class="preprocessor"> key.v[0] += PHILOX_W##W##_0; \</span>
<a name="l00282"></a>00282 <span class="preprocessor"> return key; \</span>
<a name="l00283"></a>00283 <span class="preprocessor">}</span>
<a name="l00284"></a>00284 <span class="preprocessor"></span>
<a name="l00285"></a>00285 <span class="preprocessor">#define _philox4xWround_tpl(W, T) \</span>
<a name="l00286"></a>00286 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE R123_FORCE_INLINE(struct r123array4x##W _philox4x##W##round(struct r123array4x##W ctr, struct r123array2x##W key)); \</span>
<a name="l00287"></a>00287 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE struct r123array4x##W _philox4x##W##round(struct r123array4x##W ctr, struct r123array2x##W key){ \</span>
<a name="l00288"></a>00288 <span class="preprocessor"> T hi0; \</span>
<a name="l00289"></a>00289 <span class="preprocessor"> T hi1; \</span>
<a name="l00290"></a>00290 <span class="preprocessor"> T lo0 = mulhilo##W(PHILOX_M4x##W##_0, ctr.v[0], &hi0); \</span>
<a name="l00291"></a>00291 <span class="preprocessor"> T lo1 = mulhilo##W(PHILOX_M4x##W##_1, ctr.v[2], &hi1); \</span>
<a name="l00292"></a>00292 <span class="preprocessor"> struct r123array4x##W out = {{hi1^ctr.v[1]^key.v[0], lo1, \</span>
<a name="l00293"></a>00293 <span class="preprocessor"> hi0^ctr.v[3]^key.v[1], lo0}}; \</span>
<a name="l00294"></a>00294 <span class="preprocessor"> return out; \</span>
<a name="l00295"></a>00295 <span class="preprocessor">}</span>
<a name="l00296"></a>00296 <span class="preprocessor"></span>
<a name="l00297"></a>00297 <span class="preprocessor">#define _philox4xWbumpkey_tpl(W) \</span>
<a name="l00298"></a>00298 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE struct r123array2x##W _philox4x##W##bumpkey( struct r123array2x##W key) { \</span>
<a name="l00299"></a>00299 <span class="preprocessor"> key.v[0] += PHILOX_W##W##_0; \</span>
<a name="l00300"></a>00300 <span class="preprocessor"> key.v[1] += PHILOX_W##W##_1; \</span>
<a name="l00301"></a>00301 <span class="preprocessor"> return key; \</span>
<a name="l00302"></a>00302 <span class="preprocessor">}</span>
<a name="l00303"></a>00303 <span class="preprocessor"></span>
<a name="l00304"></a>00304 <span class="preprocessor">#define _philoxNxW_tpl(N, Nhalf, W, T) \</span>
<a name="l00305"></a>00305 <span class="preprocessor"> \</span>
<a name="l00306"></a>00306 <span class="preprocessor">enum r123_enum_philox##N##x##W { philox##N##x##W##_rounds = PHILOX##N##x##W##_DEFAULT_ROUNDS }; \</span>
<a name="l00307"></a>00307 <span class="preprocessor">typedef struct r123array##N##x##W philox##N##x##W##_ctr_t; \</span>
<a name="l00308"></a>00308 <span class="preprocessor">typedef struct r123array##Nhalf##x##W philox##N##x##W##_key_t; \</span>
<a name="l00309"></a>00309 <span class="preprocessor">typedef struct r123array##Nhalf##x##W philox##N##x##W##_ukey_t; \</span>
<a name="l00310"></a>00310 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE philox##N##x##W##_key_t philox##N##x##W##keyinit(philox##N##x##W##_ukey_t uk) { return uk; } \</span>
<a name="l00311"></a>00311 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE R123_FORCE_INLINE(philox##N##x##W##_ctr_t philox##N##x##W##_R(unsigned int R, philox##N##x##W##_ctr_t ctr, philox##N##x##W##_key_t key)); \</span>
<a name="l00312"></a>00312 <span class="preprocessor">R123_CUDA_DEVICE R123_STATIC_INLINE philox##N##x##W##_ctr_t philox##N##x##W##_R(unsigned int R, philox##N##x##W##_ctr_t ctr, philox##N##x##W##_key_t key) { \</span>
<a name="l00313"></a>00313 <span class="preprocessor"> R123_ASSERT(R<=16); \</span>
<a name="l00314"></a>00314 <span class="preprocessor"> if(R>0){ ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00315"></a>00315 <span class="preprocessor"> if(R>1){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00316"></a>00316 <span class="preprocessor"> if(R>2){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00317"></a>00317 <span class="preprocessor"> if(R>3){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00318"></a>00318 <span class="preprocessor"> if(R>4){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00319"></a>00319 <span class="preprocessor"> if(R>5){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00320"></a>00320 <span class="preprocessor"> if(R>6){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00321"></a>00321 <span class="preprocessor"> if(R>7){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00322"></a>00322 <span class="preprocessor"> if(R>8){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00323"></a>00323 <span class="preprocessor"> if(R>9){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00324"></a>00324 <span class="preprocessor"> if(R>10){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00325"></a>00325 <span class="preprocessor"> if(R>11){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00326"></a>00326 <span class="preprocessor"> if(R>12){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00327"></a>00327 <span class="preprocessor"> if(R>13){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00328"></a>00328 <span class="preprocessor"> if(R>14){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00329"></a>00329 <span class="preprocessor"> if(R>15){ key = _philox##N##x##W##bumpkey(key); ctr = _philox##N##x##W##round(ctr, key); } \</span>
<a name="l00330"></a>00330 <span class="preprocessor"> return ctr; \</span>
<a name="l00331"></a>00331 <span class="preprocessor">}</span>
<a name="l00332"></a>00332 <span class="preprocessor"></span>
<a name="l00333"></a>00333 _philox2xWbumpkey_tpl(32)
<a name="l00334"></a>00334 _philox4xWbumpkey_tpl(32)
<a name="l00335"></a>00335 _philox2xWround_tpl(32, uint32_t) <span class="comment">/* philo2x32round */</span>
<a name="l00336"></a>00336 _philox4xWround_tpl(32, uint32_t) <span class="comment">/* philo4x32round */</span>
<a name="l00338"></a><a class="code" href="group__PhiloxNxW.html#gae7443e1a57429154124943b6a7c0bd08">00338</a> _philoxNxW_tpl(2, 1, 32, uint32_t) <span class="comment">/* philox2x32bijection */</span>
<a name="l00339"></a><a class="code" href="group__PhiloxNxW.html#ga67fd1bf4ed858d01663a7d6b219b97a2">00339</a> _philoxNxW_tpl(4, 2, 32, uint32_t) <span class="comment">/* philox4x32bijection */</span>
<a name="l00340"></a>00340 <span class="preprocessor">#if R123_USE_PHILOX_64BIT</span>
<a name="l00341"></a>00341 <span class="preprocessor"></span>
<a name="l00342"></a>00342 _philox2xWbumpkey_tpl(64)
<a name="l00343"></a>00343 _philox4xWbumpkey_tpl(64)
<a name="l00344"></a>00344 _philox2xWround_tpl(64, uint64_t) <span class="comment">/* philo2x64round */</span>
<a name="l00345"></a>00345 _philox4xWround_tpl(64, uint64_t) <span class="comment">/* philo4x64round */</span>
<a name="l00347"></a><a class="code" href="group__PhiloxNxW.html#gaca9df5cdadde758a63952daa97ddff91">00347</a> _philoxNxW_tpl(2, 1, 64, uint64_t) <span class="comment">/* philox2x64bijection */</span>
<a name="l00348"></a><a class="code" href="group__PhiloxNxW.html#gaf603860d055cee96c75f6986641e9cad">00348</a> _philoxNxW_tpl(4, 2, 64, uint64_t) <span class="comment">/* philox4x64bijection */</span>
<a name="l00349"></a>00349 <span class="preprocessor">#endif </span><span class="comment">/* R123_USE_PHILOX_64BIT */</span>
<a name="l00350"></a>00350
<a name="l00351"></a><a class="code" href="philox_8h.html#ab2496424917f063a4990f01943a07fe0">00351</a> <span class="preprocessor">#define philox2x32(c,k) philox2x32_R(philox2x32_rounds, c, k)</span>
<a name="l00352"></a><a class="code" href="philox_8h.html#a432a3df828dd51acd0b7ec2fee1d4d7e">00352</a> <span class="preprocessor"></span><span class="preprocessor">#define philox4x32(c,k) philox4x32_R(philox4x32_rounds, c, k)</span>
<a name="l00353"></a>00353 <span class="preprocessor"></span><span class="preprocessor">#if R123_USE_PHILOX_64BIT</span>
<a name="l00354"></a><a class="code" href="philox_8h.html#ae6b57a71e4efa369cc19416fc088b5a5">00354</a> <span class="preprocessor"></span><span class="preprocessor">#define philox2x64(c,k) philox2x64_R(philox2x64_rounds, c, k)</span>
<a name="l00355"></a><a class="code" href="philox_8h.html#a62fb1b4d9775396303ebb2a801fea8e6">00355</a> <span class="preprocessor"></span><span class="preprocessor">#define philox4x64(c,k) philox4x64_R(philox4x64_rounds, c, k)</span>
<a name="l00356"></a>00356 <span class="preprocessor"></span><span class="preprocessor">#endif </span><span class="comment">/* R123_USE_PHILOX_64BIT */</span>
<a name="l00357"></a>00357
<a name="l00358"></a>00358 <span class="preprocessor">#ifdef __cplusplus</span>
<a name="l00359"></a>00359 <span class="preprocessor"></span><span class="preprocessor">#include <stdexcept></span>
<a name="l00360"></a>00360
<a name="l00363"></a>00363 <span class="preprocessor">#define _PhiloxNxW_base_tpl(CType, KType, N, W) \</span>
<a name="l00364"></a>00364 <span class="preprocessor">namespace r123{ \</span>
<a name="l00365"></a>00365 <span class="preprocessor">template<unsigned int ROUNDS> \</span>
<a name="l00366"></a>00366 <span class="preprocessor">struct Philox##N##x##W##_R{ \</span>
<a name="l00367"></a>00367 <span class="preprocessor"> typedef CType ctr_type; \</span>
<a name="l00368"></a>00368 <span class="preprocessor"> typedef KType key_type; \</span>
<a name="l00369"></a>00369 <span class="preprocessor"> typedef KType ukey_type; \</span>
<a name="l00370"></a>00370 <span class="preprocessor"> static const unsigned int rounds=ROUNDS; \</span>
<a name="l00371"></a>00371 <span class="preprocessor"> inline R123_CUDA_DEVICE R123_FORCE_INLINE(ctr_type operator()(ctr_type ctr, key_type key) const){ \</span>
<a name="l00372"></a>00372 <span class="preprocessor"> R123_STATIC_ASSERT(ROUNDS<=16, "philox is only unrolled up to 16 rounds\n"); \</span>
<a name="l00373"></a>00373 <span class="preprocessor"> return philox##N##x##W##_R(ROUNDS, ctr, key); \</span>
<a name="l00374"></a>00374 <span class="preprocessor"> } \</span>
<a name="l00375"></a>00375 <span class="preprocessor">}; \</span>
<a name="l00376"></a>00376 <span class="preprocessor">typedef Philox##N##x##W##_R<philox##N##x##W##_rounds> Philox##N##x##W; \</span>
<a name="l00377"></a>00377 <span class="preprocessor"> } // namespace r123</span>
<a name="l00378"></a>00378 <span class="preprocessor"></span>
<a name="l00380"></a><a class="code" href="group__PhiloxNxW.html#ga81659a3ee5a1ca9e2e85c5d725a1ea4f">00380</a> _PhiloxNxW_base_tpl(<a class="code" href="structr123array2x32.html">r123array2x32</a>, <a class="code" href="structr123array1x32.html">r123array1x32</a>, 2, 32) <span class="comment">// Philox2x32_R<R></span>
<a name="l00381"></a><a class="code" href="group__PhiloxNxW.html#gaafd54060af05012db410034e3c0ecdc4">00381</a> _PhiloxNxW_base_tpl(<a class="code" href="structr123array4x32.html">r123array4x32</a>, <a class="code" href="structr123array2x32.html">r123array2x32</a>, 4, 32) <span class="comment">// Philox4x32_R<R></span>
<a name="l00382"></a>00382 <span class="preprocessor">#if R123_USE_PHILOX_64BIT</span>
<a name="l00383"></a><a class="code" href="group__PhiloxNxW.html#ga616a669079ac25119353416c14d46426">00383</a> <span class="preprocessor"></span>_PhiloxNxW_base_tpl(<a class="code" href="structr123array2x64.html">r123array2x64</a>, <a class="code" href="structr123array1x64.html">r123array1x64</a>, 2, 64) <span class="comment">// Philox2x64_R<R></span>
<a name="l00384"></a><a class="code" href="group__PhiloxNxW.html#ga7776f4d481b7c0ac00db70272a1c77f0">00384</a> _PhiloxNxW_base_tpl(<a class="code" href="structr123array4x64.html">r123array4x64</a>, <a class="code" href="structr123array2x64.html">r123array2x64</a>, 4, 64) <span class="comment">// Philox4x64_R<R></span>
<a name="l00385"></a>00385 <span class="preprocessor">#endif</span>
<a name="l00386"></a>00386 <span class="preprocessor"></span>
<a name="l00387"></a>00387 <span class="comment">/* The _tpl macros don't quite work to do string-pasting inside comments.</span>
<a name="l00388"></a>00388 <span class="comment"> so we just write out the boilerplate documentation four times... */</span>
<a name="l00389"></a>00389
<a name="l00484"></a>00484 <span class="preprocessor">#endif </span><span class="comment">/* __cplusplus */</span>
<a name="l00485"></a>00485
<a name="l00486"></a>00486 <span class="preprocessor">#endif </span><span class="comment">/* _philox_dot_h_ */</span>
</pre></div></div>
</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>
|
