source: Daodan/src/dSFMT/dSFMT.h@ 637

Last change on this file since 637 was 440, checked in by rossy, 15 years ago

int32rand

File size: 21.1 KB
Line 
1/**
2 * @file dSFMT.h
3 *
4 * @brief double precision SIMD oriented Fast Mersenne Twister(dSFMT)
5 * pseudorandom number generator based on IEEE 754 format.
6 *
7 * @author Mutsuo Saito (Hiroshima University)
8 * @author Makoto Matsumoto (Hiroshima University)
9 *
10 * Copyright (C) 2007, 2008 Mutsuo Saito, Makoto Matsumoto and
11 * Hiroshima University. All rights reserved.
12 *
13 * The new BSD License is applied to this software.
14 * see LICENSE.txt
15 *
16 * @note We assume that your system has inttypes.h. If your system
17 * doesn't have inttypes.h, you have to typedef uint32_t and uint64_t,
18 * and you have to define PRIu64 and PRIx64 in this file as follows:
19 * @verbatim
20 typedef unsigned int uint32_t
21 typedef unsigned long long uint64_t
22 #define PRIu64 "llu"
23 #define PRIx64 "llx"
24@endverbatim
25 * uint32_t must be exactly 32-bit unsigned integer type (no more, no
26 * less), and uint64_t must be exactly 64-bit unsigned integer type.
27 * PRIu64 and PRIx64 are used for printf function to print 64-bit
28 * unsigned int and 64-bit unsigned int in hexadecimal format.
29 */
30
31#ifndef DSFMT_H
32#define DSFMT_H
33
34#include <stdio.h>
35#include <assert.h>
36
37#if !defined(DSFMT_MEXP)
38#ifdef __GNUC__
39 #warning "DSFMT_MEXP is not defined. I assume DSFMT_MEXP is 19937."
40#endif
41 #define DSFMT_MEXP 19937
42#endif
43/*-----------------
44 BASIC DEFINITIONS
45 -----------------*/
46/* Mersenne Exponent. The period of the sequence
47 * is a multiple of 2^DSFMT_MEXP-1.
48 * #define DSFMT_MEXP 19937 */
49/** DSFMT generator has an internal state array of 128-bit integers,
50 * and N is its size. */
51#define DSFMT_N ((DSFMT_MEXP - 128) / 104 + 1)
52/** N32 is the size of internal state array when regarded as an array
53 * of 32-bit integers.*/
54#define DSFMT_N32 (DSFMT_N * 4)
55/** N64 is the size of internal state array when regarded as an array
56 * of 64-bit integers.*/
57#define DSFMT_N64 (DSFMT_N * 2)
58
59#if !defined(DSFMT_BIG_ENDIAN)
60# if defined(__BYTE_ORDER) && defined(__BIG_ENDIAN)
61# if __BYTE_ORDER == __BIG_ENDIAN
62# define DSFMT_BIG_ENDIAN 1
63# endif
64# elif defined(_BYTE_ORDER) && defined(_BIG_ENDIAN)
65# if _BYTE_ORDER == _BIG_ENDIAN
66# define DSFMT_BIG_ENDIAN 1
67# endif
68# elif defined(__BYTE_ORDER__) && defined(__BIG_ENDIAN__)
69# if __BYTE_ORDER__ == __BIG_ENDIAN__
70# define DSFMT_BIG_ENDIAN 1
71# endif
72# elif defined(BYTE_ORDER) && defined(BIG_ENDIAN)
73# if BYTE_ORDER == BIG_ENDIAN
74# define DSFMT_BIG_ENDIAN 1
75# endif
76# elif defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN) \
77 || defined(__BIG_ENDIAN__) || defined(BIG_ENDIAN)
78# define DSFMT_BIG_ENDIAN 1
79# endif
80#endif
81
82#if defined(DSFMT_BIG_ENDIAN) && defined(__amd64)
83# undef DSFMT_BIG_ENDIAN
84#endif
85
86#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
87# include <inttypes.h>
88#elif defined(_MSC_VER) || defined(__BORLANDC__)
89# if !defined(DSFMT_UINT32_DEFINED) && !defined(SFMT_UINT32_DEFINED)
90typedef unsigned int uint32_t;
91typedef unsigned __int64 uint64_t;
92# define UINT64_C(v) (v ## ui64)
93# define DSFMT_UINT32_DEFINED
94# if !defined(inline)
95# define inline __inline
96# endif
97# endif
98#else
99# include <inttypes.h>
100# if !defined(inline)
101# if defined(__GNUC__)
102# define inline __inline__
103# else
104# define inline
105# endif
106# endif
107#endif
108
109#ifndef PRIu64
110# if defined(_MSC_VER) || defined(__BORLANDC__)
111# define PRIu64 "I64u"
112# define PRIx64 "I64x"
113# else
114# define PRIu64 "llu"
115# define PRIx64 "llx"
116# endif
117#endif
118
119#ifndef UINT64_C
120# define UINT64_C(v) (v ## ULL)
121#endif
122
123/*------------------------------------------
124 128-bit SIMD like data type for standard C
125 ------------------------------------------*/
126#if defined(HAVE_ALTIVEC)
127# if !defined(__APPLE__)
128# include <altivec.h>
129# endif
130/** 128-bit data structure */
131union W128_T {
132 vector unsigned int s;
133 uint64_t u[2];
134 uint32_t u32[4];
135 double d[2];
136};
137
138#elif defined(HAVE_SSE2)
139# include <emmintrin.h>
140
141/** 128-bit data structure */
142union W128_T {
143 __m128i si;
144 __m128d sd;
145 uint64_t u[2];
146 uint32_t u32[4];
147 double d[2];
148};
149#else /* standard C */
150/** 128-bit data structure */
151union W128_T {
152 uint64_t u[2];
153 uint32_t u32[4];
154 double d[2];
155};
156#endif
157
158/** 128-bit data type */
159typedef union W128_T w128_t;
160
161/** the 128-bit internal state array */
162struct DSFMT_T {
163 w128_t status[DSFMT_N + 1];
164 int idx;
165};
166typedef struct DSFMT_T dsfmt_t;
167
168/** dsfmt internal state vector */
169extern dsfmt_t dsfmt_global_data;
170/** dsfmt mexp for check */
171extern const int dsfmt_global_mexp;
172
173void dsfmt_gen_rand_all(dsfmt_t *dsfmt);
174void dsfmt_fill_array_open_close(dsfmt_t *dsfmt, double array[], int size);
175void dsfmt_fill_array_close_open(dsfmt_t *dsfmt, double array[], int size);
176void dsfmt_fill_array_open_open(dsfmt_t *dsfmt, double array[], int size);
177void dsfmt_fill_array_close1_open2(dsfmt_t *dsfmt, double array[], int size);
178void dsfmt_chk_init_gen_rand(dsfmt_t *dsfmt, uint32_t seed, int mexp);
179void dsfmt_chk_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
180 int key_length, int mexp);
181const char *dsfmt_get_idstring(void);
182int dsfmt_get_min_array_size(void);
183
184#if defined(__GNUC__)
185# define DSFMT_PRE_INLINE inline static
186# define DSFMT_PST_INLINE __attribute__((always_inline))
187#elif defined(_MSC_VER) && _MSC_VER >= 1200
188# define DSFMT_PRE_INLINE __forceinline static
189# define DSFMT_PST_INLINE
190#else
191# define DSFMT_PRE_INLINE inline static
192# define DSFMT_PST_INLINE
193#endif
194DSFMT_PRE_INLINE uint32_t dsfmt_genrand_uint32(dsfmt_t *dsfmt) DSFMT_PST_INLINE;
195DSFMT_PRE_INLINE double dsfmt_genrand_close1_open2(dsfmt_t *dsfmt)
196 DSFMT_PST_INLINE;
197DSFMT_PRE_INLINE double dsfmt_genrand_close_open(dsfmt_t *dsfmt)
198 DSFMT_PST_INLINE;
199DSFMT_PRE_INLINE double dsfmt_genrand_open_close(dsfmt_t *dsfmt)
200 DSFMT_PST_INLINE;
201DSFMT_PRE_INLINE double dsfmt_genrand_open_open(dsfmt_t *dsfmt)
202 DSFMT_PST_INLINE;
203DSFMT_PRE_INLINE uint32_t dsfmt_gv_genrand_uint32(void) DSFMT_PST_INLINE;
204DSFMT_PRE_INLINE double dsfmt_gv_genrand_close1_open2(void) DSFMT_PST_INLINE;
205DSFMT_PRE_INLINE double dsfmt_gv_genrand_close_open(void) DSFMT_PST_INLINE;
206DSFMT_PRE_INLINE double dsfmt_gv_genrand_open_close(void) DSFMT_PST_INLINE;
207DSFMT_PRE_INLINE double dsfmt_gv_genrand_open_open(void) DSFMT_PST_INLINE;
208DSFMT_PRE_INLINE void dsfmt_gv_fill_array_open_close(double array[], int size)
209 DSFMT_PST_INLINE;
210DSFMT_PRE_INLINE void dsfmt_gv_fill_array_close_open(double array[], int size)
211 DSFMT_PST_INLINE;
212DSFMT_PRE_INLINE void dsfmt_gv_fill_array_open_open(double array[], int size)
213 DSFMT_PST_INLINE;
214DSFMT_PRE_INLINE void dsfmt_gv_fill_array_close1_open2(double array[], int size)
215 DSFMT_PST_INLINE;
216DSFMT_PRE_INLINE void dsfmt_gv_init_gen_rand(uint32_t seed) DSFMT_PST_INLINE;
217DSFMT_PRE_INLINE void dsfmt_gv_init_by_array(uint32_t init_key[],
218 int key_length) DSFMT_PST_INLINE;
219DSFMT_PRE_INLINE void dsfmt_init_gen_rand(dsfmt_t *dsfmt, uint32_t seed)
220 DSFMT_PST_INLINE;
221DSFMT_PRE_INLINE void dsfmt_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
222 int key_length) DSFMT_PST_INLINE;
223
224/**
225 * This function generates and returns unsigned 32-bit integer.
226 * This is slower than SFMT, only for convenience usage.
227 * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
228 * before this function.
229 * @param dsfmt dsfmt internal state date
230 * @return double precision floating point pseudorandom number
231 */
232inline static uint32_t dsfmt_genrand_uint32(dsfmt_t *dsfmt) {
233 uint32_t r;
234 uint64_t *psfmt64 = &dsfmt->status[0].u[0];
235
236 if (dsfmt->idx >= DSFMT_N64) {
237 dsfmt_gen_rand_all(dsfmt);
238 dsfmt->idx = 0;
239 }
240 r = psfmt64[dsfmt->idx++] & 0xffffffffU;
241 return r;
242}
243
244/**
245 * This function generates and returns double precision pseudorandom
246 * number which distributes uniformly in the range [1, 2). This is
247 * the primitive and faster than generating numbers in other ranges.
248 * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
249 * before this function.
250 * @param dsfmt dsfmt internal state date
251 * @return double precision floating point pseudorandom number
252 */
253inline static double dsfmt_genrand_close1_open2(dsfmt_t *dsfmt) {
254 double r;
255 double *psfmt64 = &dsfmt->status[0].d[0];
256
257 if (dsfmt->idx >= DSFMT_N64) {
258 dsfmt_gen_rand_all(dsfmt);
259 dsfmt->idx = 0;
260 }
261 r = psfmt64[dsfmt->idx++];
262 return r;
263}
264
265/**
266 * This function generates and returns unsigned 32-bit integer.
267 * This is slower than SFMT, only for convenience usage.
268 * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
269 * before this function. This function uses \b global variables.
270 * @return double precision floating point pseudorandom number
271 */
272inline static uint32_t dsfmt_gv_genrand_uint32(void) {
273 return dsfmt_genrand_uint32(&dsfmt_global_data);
274}
275
276/**
277 * This function generates and returns double precision pseudorandom
278 * number which distributes uniformly in the range [1, 2).
279 * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
280 * before this function. This function uses \b global variables.
281 * @return double precision floating point pseudorandom number
282 */
283inline static double dsfmt_gv_genrand_close1_open2(void) {
284 return dsfmt_genrand_close1_open2(&dsfmt_global_data);
285}
286
287/**
288 * This function generates and returns double precision pseudorandom
289 * number which distributes uniformly in the range [0, 1).
290 * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
291 * before this function.
292 * @param dsfmt dsfmt internal state date
293 * @return double precision floating point pseudorandom number
294 */
295inline static double dsfmt_genrand_close_open(dsfmt_t *dsfmt) {
296 return dsfmt_genrand_close1_open2(dsfmt) - 1.0;
297}
298
299/**
300 * This function generates and returns double precision pseudorandom
301 * number which distributes uniformly in the range [0, 1).
302 * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
303 * before this function. This function uses \b global variables.
304 * @return double precision floating point pseudorandom number
305 */
306inline static double dsfmt_gv_genrand_close_open(void) {
307 return dsfmt_gv_genrand_close1_open2() - 1.0;
308}
309
310/**
311 * This function generates and returns double precision pseudorandom
312 * number which distributes uniformly in the range (0, 1].
313 * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
314 * before this function.
315 * @param dsfmt dsfmt internal state date
316 * @return double precision floating point pseudorandom number
317 */
318inline static double dsfmt_genrand_open_close(dsfmt_t *dsfmt) {
319 return 2.0 - dsfmt_genrand_close1_open2(dsfmt);
320}
321
322/**
323 * This function generates and returns double precision pseudorandom
324 * number which distributes uniformly in the range (0, 1].
325 * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
326 * before this function. This function uses \b global variables.
327 * @return double precision floating point pseudorandom number
328 */
329inline static double dsfmt_gv_genrand_open_close(void) {
330 return 2.0 - dsfmt_gv_genrand_close1_open2();
331}
332
333/**
334 * This function generates and returns double precision pseudorandom
335 * number which distributes uniformly in the range (0, 1).
336 * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
337 * before this function.
338 * @param dsfmt dsfmt internal state date
339 * @return double precision floating point pseudorandom number
340 */
341inline static double dsfmt_genrand_open_open(dsfmt_t *dsfmt) {
342 double *dsfmt64 = &dsfmt->status[0].d[0];
343 union {
344 double d;
345 uint64_t u;
346 } r;
347
348 if (dsfmt->idx >= DSFMT_N64) {
349 dsfmt_gen_rand_all(dsfmt);
350 dsfmt->idx = 0;
351 }
352 r.d = dsfmt64[dsfmt->idx++];
353 r.u |= 1;
354 return r.d - 1.0;
355}
356
357/**
358 * This function generates and returns double precision pseudorandom
359 * number which distributes uniformly in the range (0, 1).
360 * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
361 * before this function. This function uses \b global variables.
362 * @return double precision floating point pseudorandom number
363 */
364inline static double dsfmt_gv_genrand_open_open(void) {
365 return dsfmt_genrand_open_open(&dsfmt_global_data);
366}
367
368/**
369 * This function generates double precision floating point
370 * pseudorandom numbers which distribute in the range [1, 2) to the
371 * specified array[] by one call. This function is the same as
372 * dsfmt_fill_array_close1_open2() except that this function uses
373 * \b global variables.
374 * @param array an array where pseudorandom numbers are filled
375 * by this function.
376 * @param size the number of pseudorandom numbers to be generated.
377 * see also \sa dsfmt_fill_array_close1_open2()
378 */
379inline static void dsfmt_gv_fill_array_close1_open2(double array[], int size) {
380 dsfmt_fill_array_close1_open2(&dsfmt_global_data, array, size);
381}
382
383/**
384 * This function generates double precision floating point
385 * pseudorandom numbers which distribute in the range (0, 1] to the
386 * specified array[] by one call. This function is the same as
387 * dsfmt_gv_fill_array_close1_open2() except the distribution range.
388 * This function uses \b global variables.
389 * @param array an array where pseudorandom numbers are filled
390 * by this function.
391 * @param size the number of pseudorandom numbers to be generated.
392 * see also \sa dsfmt_fill_array_close1_open2() and \sa
393 * dsfmt_gv_fill_array_close1_open2()
394 */
395inline static void dsfmt_gv_fill_array_open_close(double array[], int size) {
396 dsfmt_fill_array_open_close(&dsfmt_global_data, array, size);
397}
398
399/**
400 * This function generates double precision floating point
401 * pseudorandom numbers which distribute in the range [0, 1) to the
402 * specified array[] by one call. This function is the same as
403 * dsfmt_gv_fill_array_close1_open2() except the distribution range.
404 * This function uses \b global variables.
405 * @param array an array where pseudorandom numbers are filled
406 * by this function.
407 * @param size the number of pseudorandom numbers to be generated.
408 * see also \sa dsfmt_fill_array_close1_open2() \sa
409 * dsfmt_gv_fill_array_close1_open2()
410 */
411inline static void dsfmt_gv_fill_array_close_open(double array[], int size) {
412 dsfmt_fill_array_close_open(&dsfmt_global_data, array, size);
413}
414
415/**
416 * This function generates double precision floating point
417 * pseudorandom numbers which distribute in the range (0, 1) to the
418 * specified array[] by one call. This function is the same as
419 * dsfmt_gv_fill_array_close1_open2() except the distribution range.
420 * This function uses \b global variables.
421 * @param array an array where pseudorandom numbers are filled
422 * by this function.
423 * @param size the number of pseudorandom numbers to be generated.
424 * see also \sa dsfmt_fill_array_close1_open2() \sa
425 * dsfmt_gv_fill_array_close1_open2()
426 */
427inline static void dsfmt_gv_fill_array_open_open(double array[], int size) {
428 dsfmt_fill_array_open_open(&dsfmt_global_data, array, size);
429}
430
431/**
432 * This function initializes the internal state array with a 32-bit
433 * integer seed.
434 * @param dsfmt dsfmt state vector.
435 * @param seed a 32-bit integer used as the seed.
436 */
437inline static void dsfmt_init_gen_rand(dsfmt_t *dsfmt, uint32_t seed) {
438 dsfmt_chk_init_gen_rand(dsfmt, seed, DSFMT_MEXP);
439}
440
441/**
442 * This function initializes the internal state array with a 32-bit
443 * integer seed. This function uses \b global variables.
444 * @param seed a 32-bit integer used as the seed.
445 * see also \sa dsfmt_init_gen_rand()
446 */
447inline static void dsfmt_gv_init_gen_rand(uint32_t seed) {
448 dsfmt_init_gen_rand(&dsfmt_global_data, seed);
449}
450
451/**
452 * This function initializes the internal state array,
453 * with an array of 32-bit integers used as the seeds.
454 * @param dsfmt dsfmt state vector
455 * @param init_key the array of 32-bit integers, used as a seed.
456 * @param key_length the length of init_key.
457 */
458inline static void dsfmt_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
459 int key_length) {
460 dsfmt_chk_init_by_array(dsfmt, init_key, key_length, DSFMT_MEXP);
461}
462
463/**
464 * This function initializes the internal state array,
465 * with an array of 32-bit integers used as the seeds.
466 * This function uses \b global variables.
467 * @param init_key the array of 32-bit integers, used as a seed.
468 * @param key_length the length of init_key.
469 * see also \sa dsfmt_init_by_array()
470 */
471inline static void dsfmt_gv_init_by_array(uint32_t init_key[], int key_length) {
472 dsfmt_init_by_array(&dsfmt_global_data, init_key, key_length);
473}
474
475#if !defined(DSFMT_DO_NOT_USE_OLD_NAMES)
476DSFMT_PRE_INLINE const char *get_idstring(void) DSFMT_PST_INLINE;
477DSFMT_PRE_INLINE int get_min_array_size(void) DSFMT_PST_INLINE;
478DSFMT_PRE_INLINE void init_gen_rand(uint32_t seed) DSFMT_PST_INLINE;
479DSFMT_PRE_INLINE void init_by_array(uint32_t init_key[], int key_length)
480 DSFMT_PST_INLINE;
481DSFMT_PRE_INLINE double genrand_close1_open2(void) DSFMT_PST_INLINE;
482DSFMT_PRE_INLINE double genrand_close_open(void) DSFMT_PST_INLINE;
483DSFMT_PRE_INLINE double genrand_open_close(void) DSFMT_PST_INLINE;
484DSFMT_PRE_INLINE double genrand_open_open(void) DSFMT_PST_INLINE;
485DSFMT_PRE_INLINE void fill_array_open_close(double array[], int size)
486 DSFMT_PST_INLINE;
487DSFMT_PRE_INLINE void fill_array_close_open(double array[], int size)
488 DSFMT_PST_INLINE;
489DSFMT_PRE_INLINE void fill_array_open_open(double array[], int size)
490 DSFMT_PST_INLINE;
491DSFMT_PRE_INLINE void fill_array_close1_open2(double array[], int size)
492 DSFMT_PST_INLINE;
493
494/**
495 * This function is just the same as dsfmt_get_idstring().
496 * @return id string.
497 * see also \sa dsfmt_get_idstring()
498 */
499inline static const char *get_idstring(void) {
500 return dsfmt_get_idstring();
501}
502
503/**
504 * This function is just the same as dsfmt_get_min_array_size().
505 * @return minimum size of array used for fill_array functions.
506 * see also \sa dsfmt_get_min_array_size()
507 */
508inline static int get_min_array_size(void) {
509 return dsfmt_get_min_array_size();
510}
511
512/**
513 * This function is just the same as dsfmt_gv_init_gen_rand().
514 * @param seed a 32-bit integer used as the seed.
515 * see also \sa dsfmt_gv_init_gen_rand(), \sa dsfmt_init_gen_rand().
516 */
517inline static void init_gen_rand(uint32_t seed) {
518 dsfmt_gv_init_gen_rand(seed);
519}
520
521/**
522 * This function is just the same as dsfmt_gv_init_by_array().
523 * @param init_key the array of 32-bit integers, used as a seed.
524 * @param key_length the length of init_key.
525 * see also \sa dsfmt_gv_init_by_array(), \sa dsfmt_init_by_array().
526 */
527inline static void init_by_array(uint32_t init_key[], int key_length) {
528 dsfmt_gv_init_by_array(init_key, key_length);
529}
530
531/**
532 * This function is just the same as dsfmt_gv_genrand_close1_open2().
533 * @return double precision floating point number.
534 * see also \sa dsfmt_genrand_close1_open2() \sa
535 * dsfmt_gv_genrand_close1_open2()
536 */
537inline static double genrand_close1_open2(void) {
538 return dsfmt_gv_genrand_close1_open2();
539}
540
541/**
542 * This function is just the same as dsfmt_gv_genrand_close_open().
543 * @return double precision floating point number.
544 * see also \sa dsfmt_genrand_close_open() \sa
545 * dsfmt_gv_genrand_close_open()
546 */
547inline static double genrand_close_open(void) {
548 return dsfmt_gv_genrand_close_open();
549}
550
551/**
552 * This function is just the same as dsfmt_gv_genrand_open_close().
553 * @return double precision floating point number.
554 * see also \sa dsfmt_genrand_open_close() \sa
555 * dsfmt_gv_genrand_open_close()
556 */
557inline static double genrand_open_close(void) {
558 return dsfmt_gv_genrand_open_close();
559}
560
561/**
562 * This function is just the same as dsfmt_gv_genrand_open_open().
563 * @return double precision floating point number.
564 * see also \sa dsfmt_genrand_open_open() \sa
565 * dsfmt_gv_genrand_open_open()
566 */
567inline static double genrand_open_open(void) {
568 return dsfmt_gv_genrand_open_open();
569}
570
571/**
572 * This function is juset the same as dsfmt_gv_fill_array_open_close().
573 * @param array an array where pseudorandom numbers are filled
574 * by this function.
575 * @param size the number of pseudorandom numbers to be generated.
576 * see also \sa dsfmt_gv_fill_array_open_close(), \sa
577 * dsfmt_fill_array_close1_open2(), \sa
578 * dsfmt_gv_fill_array_close1_open2()
579 */
580inline static void fill_array_open_close(double array[], int size) {
581 dsfmt_gv_fill_array_open_close(array, size);
582}
583
584/**
585 * This function is juset the same as dsfmt_gv_fill_array_close_open().
586 * @param array an array where pseudorandom numbers are filled
587 * by this function.
588 * @param size the number of pseudorandom numbers to be generated.
589 * see also \sa dsfmt_gv_fill_array_close_open(), \sa
590 * dsfmt_fill_array_close1_open2(), \sa
591 * dsfmt_gv_fill_array_close1_open2()
592 */
593inline static void fill_array_close_open(double array[], int size) {
594 dsfmt_gv_fill_array_close_open(array, size);
595}
596
597/**
598 * This function is juset the same as dsfmt_gv_fill_array_open_open().
599 * @param array an array where pseudorandom numbers are filled
600 * by this function.
601 * @param size the number of pseudorandom numbers to be generated.
602 * see also \sa dsfmt_gv_fill_array_open_open(), \sa
603 * dsfmt_fill_array_close1_open2(), \sa
604 * dsfmt_gv_fill_array_close1_open2()
605 */
606inline static void fill_array_open_open(double array[], int size) {
607 dsfmt_gv_fill_array_open_open(array, size);
608}
609
610/**
611 * This function is juset the same as dsfmt_gv_fill_array_close1_open2().
612 * @param array an array where pseudorandom numbers are filled
613 * by this function.
614 * @param size the number of pseudorandom numbers to be generated.
615 * see also \sa dsfmt_fill_array_close1_open2(), \sa
616 * dsfmt_gv_fill_array_close1_open2()
617 */
618inline static void fill_array_close1_open2(double array[], int size) {
619 dsfmt_gv_fill_array_close1_open2(array, size);
620}
621#endif /* DSFMT_DO_NOT_USE_OLD_NAMES */
622
623#endif /* DSFMT_H */
Note: See TracBrowser for help on using the repository browser.