Luxophia

1
unit LUX.Random.WELL.P19937;
2

3
{ http://www.iro.umontreal.ca/~panneton/WELLRNG.html }
4

5
interface //#################################################################### ■
6

7
uses System.SysUtils,
8
     LUX,
9
     LUX.Random,
10
     LUX.Random.WELL;
11

12
type //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【型】
13

14
     TRandom32WEL19937a      = class;
15
       TRandom32WEL19937c    = class;
16
       TRandom32WEL19937anew = class;
17

18
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
19

20
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSeed32WEL19937a
21

22
     TSeed32WEL19937a = record
23
     private const
24
       W     = 32;
25
       R     = 624;
26
       P     = 31;
27
       MASKU = $ffffffff shr ( W - P );
28
       MASKL = not MASKU;
29
       M1    = 70;
30
       M2    = 179;
31
       M3    = 449;
32
     private
33
       ///// アクセス
34
       function GetV0 :Int32u;
35
       procedure SetV0( const V0_:Int32u );
36
       function GetVM1Over :Int32u;
37
       procedure SetVM1Over( const VM1Over_:Int32u );
38
       function GetVM1 :Int32u;
39
       procedure SetVM1( const VM1_:Int32u );
40
       function GetVM2Over :Int32u;
41
       procedure SetVM2Over( const VM2Over_:Int32u );
42
       function GetVM2 :Int32u;
43
       procedure SetVM2( const VM2_:Int32u );
44
       function GetVM3Over :Int32u;
45
       procedure SetVM3Over( const VM3Over_:Int32u );
46
       function GetVM3 :Int32u;
47
       procedure SetVM3( const VM3_:Int32u );
48
       function GetVRm1 :Int32u;
49
       procedure SetVRm1( const VRm1_:Int32u );
50
       function GetVRm1Under :Int32u;
51
       procedure SetVRm1Under( const VRm1Under_:Int32u );
52
       function GetVRm2 :Int32u;
53
       procedure SetVRm2( const VRm2_:Int32u );
54
       function GetVRm2Under :Int32u;
55
       procedure SetVRm2Under( const VRm2Under_:Int32u );
56
       function GetnewV0 :Int32u;
57
       procedure SetnewV0( const newV0_:Int32u );
58
       function GetnewV0Under :Int32u;
59
       procedure SetnewV0Under( const newV0Under_:Int32u );
60
       function GetnewV1 :Int32u;
61
       procedure SetnewV1( const newV1_:Int32u );
62
       function GetnewVRm1 :Int32u;
63
       procedure SetnewVRm1( const newVRm1_:Int32u );
64
       function GetnewVRm1Under :Int32u;
65
       procedure SetnewVRm1Under( const newVRm1Under_:Int32u );
66
       { WELL19937a-new }
67
       function GetnewVM2Over :Int32u;
68
       procedure SetnewVM2Over( const newVM2Over_:Int32u );
69
       function GetnewVM2 :Int32u;
70
       procedure SetnewVM2( const newVM2_:Int32u );
71
     public
72
       state_i :Int32u;
73
       STATE   :array [ 0..R-1 ] of Int32u;
74
       case_i  :Byte;
75
       ///// プロパティ
76
       property V0           :Int32u read GetV0           write SetV0          ;
77
       property VM1Over      :Int32u read GetVM1Over      write SetVM1Over     ;
78
       property VM1          :Int32u read GetVM1          write SetVM1         ;
79
       property VM2Over      :Int32u read GetVM2Over      write SetVM2Over     ;
80
       property VM2          :Int32u read GetVM2          write SetVM2         ;
81
       property VM3Over      :Int32u read GetVM3Over      write SetVM3Over     ;
82
       property VM3          :Int32u read GetVM3          write SetVM3         ;
83
       property VRm1         :Int32u read GetVRm1         write SetVRm1        ;
84
       property VRm1Under    :Int32u read GetVRm1Under    write SetVRm1Under   ;
85
       property VRm2         :Int32u read GetVRm2         write SetVRm2        ;
86
       property VRm2Under    :Int32u read GetVRm2Under    write SetVRm2Under   ;
87
       property newV0        :Int32u read GetnewV0        write SetnewV0       ;
88
       property newV0Under   :Int32u read GetnewV0Under   write SetnewV0Under  ;
89
       property newV1        :Int32u read GetnewV1        write SetnewV1       ;
90
       property newVRm1      :Int32u read GetnewVRm1      write SetnewVRm1     ;
91
       property newVRm1Under :Int32u read GetnewVRm1Under write SetnewVRm1Under;
92
       { WELL19937a-new }
93
       property newVM2Over   :Int32u read GetnewVM2Over   write SetnewVM2Over  ;
94
       property newVM2       :Int32u read GetnewVM2       write SetnewVM2      ;
95
     end;
96

97
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
98

99
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TRandom32WEL19937a
100

101
     TRandom32WEL19937a = class( TRandomWEL<TSeed32WEL19937a> )
102
     protected
103
       ///// メソッド
104
       procedure case_1;
105
       procedure case_2;
106
       procedure case_3;
107
       procedure case_4;
108
       procedure case_5;
109
       procedure case_6;
110
       procedure CalcNextSeed; override;
111
       function CalcRandInt32u :Int32u; override;
112
     public
113
       constructor CreateFromRand( const Random_:IRandom ); overload; override;
114
       ///// メソッド
115
       function MAT0POS( const t:Int32u; const v:Int32u ) :Int32u; inline;
116
       function MAT0NEG( const t:Int32s; const v:Int32u ) :Int32u; inline;
117
       function MAT1( const v:Int32u ) :Int32u; inline;
118
       function MAT3POS( const t:Int32u; const v:Int32u ) :Int32u; inline;
119
     end;
120

121
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TRandom32WEL19937c
122

123
     TRandom32WEL19937c = class( TRandom32WEL19937a )
124
     private const
125
       TEMPERB = $e46e1700;
126
       TEMPERC = $9b868000;
127
     private
128
     protected
129
       ///// メソッド
130
       function CalcRandInt32u :Int32u; override;
131
     public
132
     end;
133

134
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TRandom32WEL19937anew
135

136
     TRandom32WEL19937anew = class( TRandom32WEL19937a )
137
     private const
138
       BITMASK = $41180000;
139
     private
140
     protected
141
       ///// メソッド
142
       function CalcRandInt32u :Int32u; override;
143
     public
144
     end;
145

146
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
147

148
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
149

150
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
151

152
implementation //############################################################### ■
153

154
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
155

156
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSeed32WEL19937a
157

158
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
159

160
/////////////////////////////////////////////////////////////////////// アクセス
161

162
function TSeed32WEL19937a.GetV0 :Int32u;
163
begin
164
     Result := STATE[ state_i ];
165
end;
166

167
procedure TSeed32WEL19937a.SetV0( const V0_:Int32u );
168
begin
169
     STATE[ state_i ] := V0_;
170
end;
171

172
function TSeed32WEL19937a.GetVM1Over :Int32u;
173
begin
174
     Result := STATE[ state_i+M1-R ];
175
end;
176

177
procedure TSeed32WEL19937a.SetVM1Over( const VM1Over_:Int32u );
178
begin
179
     STATE[ state_i+M1-R ] := VM1Over_;
180
end;
181

182
function TSeed32WEL19937a.GetVM1 :Int32u;
183
begin
184
     Result := STATE[ state_i+M1 ];
185
end;
186

187
procedure TSeed32WEL19937a.SetVM1( const VM1_:Int32u );
188
begin
189
     STATE[ state_i+M1 ] := VM1_;
190
end;
191

192
function TSeed32WEL19937a.GetVM2Over :Int32u;
193
begin
194
     Result := STATE[ state_i+M2-R ];
195
end;
196

197
procedure TSeed32WEL19937a.SetVM2Over( const VM2Over_:Int32u );
198
begin
199
     STATE[ state_i+M2-R ] := VM2Over_;
200
end;
201

202
function TSeed32WEL19937a.GetVM2 :Int32u;
203
begin
204
     Result := STATE[ state_i+M2 ];
205
end;
206

207
procedure TSeed32WEL19937a.SetVM2( const VM2_:Int32u );
208
begin
209
     STATE[ state_i+M2 ] := VM2_;
210
end;
211

212
function TSeed32WEL19937a.GetVM3Over :Int32u;
213
begin
214
     Result := STATE[ state_i+M3-R ];
215
end;
216

217
procedure TSeed32WEL19937a.SetVM3Over( const VM3Over_:Int32u );
218
begin
219
     STATE[ state_i+M3-R ] := VM3Over_;
220
end;
221

222
function TSeed32WEL19937a.GetVM3 :Int32u;
223
begin
224
     Result := STATE[ state_i+M3 ];
225
end;
226

227
procedure TSeed32WEL19937a.SetVM3( const VM3_:Int32u );
228
begin
229
     STATE[ state_i+M3 ] := VM3_;
230
end;
231

232
function TSeed32WEL19937a.GetVRm1 :Int32u;
233
begin
234
     Result := STATE[ state_i-1 ];
235
end;
236

237
procedure TSeed32WEL19937a.SetVRm1( const VRm1_:Int32u );
238
begin
239
     STATE[ state_i-1 ] := VRm1_;
240
end;
241

242
function TSeed32WEL19937a.GetVRm1Under :Int32u;
243
begin
244
     Result := STATE[ state_i+R-1 ];
245
end;
246

247
procedure TSeed32WEL19937a.SetVRm1Under( const VRm1Under_:Int32u );
248
begin
249
     STATE[ state_i+R-1 ] := VRm1Under_;
250
end;
251

252
function TSeed32WEL19937a.GetVRm2 :Int32u;
253
begin
254
     Result := STATE[ state_i-2 ];
255
end;
256

257
procedure TSeed32WEL19937a.SetVRm2( const VRm2_:Int32u );
258
begin
259
     STATE[ state_i-2 ] := VRm2_;
260
end;
261

262
function TSeed32WEL19937a.GetVRm2Under :Int32u;
263
begin
264
     Result := STATE[ state_i+R-2 ];
265
end;
266

267
procedure TSeed32WEL19937a.SetVRm2Under( const VRm2Under_:Int32u );
268
begin
269
     STATE[ state_i+R-2 ] := VRm2Under_;
270
end;
271

272
function TSeed32WEL19937a.GetnewV0 :Int32u;
273
begin
274
     Result := STATE[ state_i-1 ];
275
end;
276

277
procedure TSeed32WEL19937a.SetnewV0( const newV0_:Int32u );
278
begin
279
     STATE[ state_i-1 ] := newV0_;
280
end;
281

282
function TSeed32WEL19937a.GetnewV0Under :Int32u;
283
begin
284
     Result := STATE[ state_i-1+R ];
285
end;
286

287
procedure TSeed32WEL19937a.SetnewV0Under( const newV0Under_:Int32u );
288
begin
289
     STATE[ state_i-1+R ] := newV0Under_;
290
end;
291

292
function TSeed32WEL19937a.GetnewV1 :Int32u;
293
begin
294
     Result := STATE[ state_i ];
295
end;
296

297
procedure TSeed32WEL19937a.SetnewV1( const newV1_:Int32u );
298
begin
299
     STATE[ state_i ] := newV1_;
300
end;
301

302
function TSeed32WEL19937a.GetnewVRm1 :Int32u;
303
begin
304
     Result := STATE[ state_i-2 ];
305
end;
306

307
procedure TSeed32WEL19937a.SetnewVRm1( const newVRm1_:Int32u );
308
begin
309
     STATE[ state_i-2 ] := newVRm1_;
310
end;
311

312
function TSeed32WEL19937a.GetnewVRm1Under :Int32u;
313
begin
314
     Result := STATE[ state_i-2+R ];
315
end;
316

317
procedure TSeed32WEL19937a.SetnewVRm1Under( const newVRm1Under_:Int32u );
318
begin
319
     STATE[ state_i-2+R ] := newVRm1Under_;
320
end;
321

322
{ WELL19937a-new }
323

324
function TSeed32WEL19937a.GetnewVM2Over :Int32u;
325
begin
326
     Result := STATE[ state_i+M2-R+1 ];
327
end;
328

329
procedure TSeed32WEL19937a.SetnewVM2Over( const newVM2Over_:Int32u );
330
begin
331
     STATE[ state_i+M2-R+1 ] := newVM2Over_;
332
end;
333

334
function TSeed32WEL19937a.GetnewVM2 :Int32u;
335
begin
336
     Result := STATE[ state_i+M2+1 ];
337
end;
338

339
procedure TSeed32WEL19937a.SetnewVM2( const newVM2_:Int32u );
340
begin
341
     STATE[ state_i+M2+1 ] := newVM2_;
342
end;
343

344
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
345

346
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
347

348
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TRandom32WEL19937a
349

350
{ http://www.iro.umontreal.ca/~panneton/well/WELL19937a.c }
351

352
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
353

354
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
355

356
/////////////////////////////////////////////////////////////////////// メソッド
357

358
procedure TRandom32WEL19937a.case_1;
359
var
360
   z0, z1, z2 :Int32u;
361
begin
362
     with _Seed do
363
     begin
364
          z0 := ( VRm1Under and MASKL )
365
             or ( VRm2Under and MASKU );
366
          z1 := MAT0NEG( -25, V0  )
367
            xor MAT0POS( +27, VM1 );
368
          z2 := MAT3POS( +09, VM2 )
369
            xor MAT0POS( +01, VM3 );
370

371
          newV1      := z1 xor z2;
372
          newV0Under := MAT1( z0 )
373
                    xor MAT0NEG( -09, z1    )
374
                    xor MAT0NEG( -21, z2    )
375
                    xor MAT0POS( +21, newV1 );
376

377
          state_i := R - 1;
378

379

380
     end;
381
end;
382

383
procedure TRandom32WEL19937a.case_2;
384
var
385
   z0, z1, z2 :Int32u;
386
begin
387
     with _Seed do
388
     begin
389
          z0 := ( VRm1      and MASKL )
390
             or ( VRm2Under and MASKU );
391
          z1 := MAT0NEG( -25, V0  )
392
            xor MAT0POS( +27, VM1 );
393
          z2 := MAT3POS( +09, VM2 )
394
            xor MAT0POS( +01, VM3 );
395

396
          newV1 := z1 xor z2;
397
          newV0 := MAT1( z0 )
398
               xor MAT0NEG( -09, z1    )
399
               xor MAT0NEG( -21, z2    )
400
               xor MAT0POS( +21, newV1 );
401

402
          state_i := 0;
403

404

405
     end;
406
end;
407

408
procedure TRandom32WEL19937a.case_3;
409
var
410
   z0, z1, z2 :Int32u;
411
begin
412
     with _Seed do
413
     begin
414
          z0 := ( VRm1 and MASKL )
415
             or ( VRm2 and MASKU );
416
          z1 := MAT0NEG( -25, V0      )
417
            xor MAT0POS( +27, VM1Over );
418
          z2 := MAT3POS( +09, VM2Over )
419
            xor MAT0POS( +01, VM3Over );
420

421
          newV1 := z1 xor z2;
422
          newV0 := MAT1( z0 )
423
               xor MAT0NEG( -09, z1    )
424
               xor MAT0NEG( -21, z2    )
425
               xor MAT0POS( +21, newV1 );
426

427
          Dec( state_i );
428

429

430
     end;
431
end;
432

433
procedure TRandom32WEL19937a.case_4;
434
var
435
   z0, z1, z2 :Int32u;
436
begin
437
     with _Seed do
438
     begin
439
          z0 := ( VRm1 and MASKL )
440
             or ( VRm2 and MASKU );
441
          z1 := MAT0NEG( -25, V0      )
442
            xor MAT0POS( +27, VM1     );
443
          z2 := MAT3POS( +09, VM2     )
444
            xor MAT0POS( +01, VM3Over );
445

446
          newV1 := z1 xor z2;
447
          newV0 := MAT1( z0 )
448
               xor MAT0NEG( -09, z1    )
449
               xor MAT0NEG( -21, z2    )
450
               xor MAT0POS( +21, newV1 );
451

452
          Dec( state_i );
453

454

455
     end;
456
end;
457

458
procedure TRandom32WEL19937a.case_5;
459
var
460
   z0, z1, z2 :Int32u;
461
begin
462
     with _Seed do
463
     begin
464
          z0 := ( VRm1 and MASKL )
465
             or ( VRm2 and MASKU );
466
          z1 := MAT0NEG( -25, V0      )
467
            xor MAT0POS( +27, VM1     );
468
          z2 := MAT3POS( +09, VM2Over )
469
            xor MAT0POS( +01, VM3Over );
470

471
          newV1 := z1 xor z2;
472
          newV0 := MAT1( z0 )
473
               xor MAT0NEG( -09, z1    )
474
               xor MAT0NEG( -21, z2    )
475
               xor MAT0POS( +21, newV1 );
476

477
          Dec( state_i );
478
     end;
479
end;
480

481
procedure TRandom32WEL19937a.case_6;
482
var
483
   z0, z1, z2 :Int32u;
484
begin
485
     with _Seed do
486
     begin
487
          z0 := ( VRm1 and MASKL )
488
             or ( VRm2 and MASKU );
489
          z1 := MAT0NEG( -25, V0  )
490
            xor MAT0POS( +27, VM1 );
491
          z2 := MAT3POS( +09, VM2 )
492
            xor MAT0POS( +01, VM3 );
493

494
          newV1 := z1 xor z2;
495
          newV0 := MAT1( z0 )
496
               xor MAT0NEG( -09, z1    )
497
               xor MAT0NEG( -21, z2    )
498
               xor MAT0POS( +21, newV1 );
499

500
          Dec( state_i );
501
     end;
502
end;
503

504
//------------------------------------------------------------------------------
505

506
procedure TRandom32WEL19937a.CalcNextSeed;
507
begin
508
     with _Seed do
509
     begin
510
          case case_i of
511
            1:                          case_i := 3;
512
            2:                          case_i := 1;
513
            3: if state_i + M1 < R then case_i := 5;
514
            4: if state_i + M3 < R then case_i := 6;
515
            5: if state_i + M2 < R then case_i := 4;
516
            6: if state_i      = 1 then case_i := 2;
517
          end;
518

519
          case case_i of
520
            1: case_1;  // 0     = state_i
521
            2: case_2;  // 1     = state_i
522
            3: case_3;  // R-M1 <= state_i
523
            4: case_4;  // R-M3 <= state_i
524
            5: case_5;  // R-M2 <= state_i
525
            6: case_6;  // 2    <= state_i <= R-M3-1
526
          end;
527
     end;
528
end;
529

530
function TRandom32WEL19937a.CalcRandInt32u :Int32u;
531
begin
532
     Result := _Seed.V0;
533
end;
534

535
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
536

537
constructor TRandom32WEL19937a.CreateFromRand( const Random_:IRandom );
538
var
539
   S :TSeed32WEL19937a;
540
   I :Integer;
541
begin
542
     with S do
543
     begin
544
          for I := 0 to R-1 do STATE[ I ] := Random_.DrawRandInt32u;
545

546
          state_i := 0;
547
          case_i  := 2;
548
     end;
549

550
     Create( S );
551
end;
552

553
/////////////////////////////////////////////////////////////////////// メソッド
554

555
function TRandom32WEL19937a.MAT0POS( const t:Int32u; const v:Int32u ) :Int32u;
556
begin
557
     Result := v xor ( v shr +t );
558
end;
559

560
function TRandom32WEL19937a.MAT0NEG( const t:Int32s; const v:Int32u ) :Int32u;
561
begin
562
     Result := v xor ( v shl -t );
563
end;
564

565
function TRandom32WEL19937a.MAT1( const v:Int32u ) :Int32u;
566
begin
567
     Result := v;
568
end;
569

570
function TRandom32WEL19937a.MAT3POS( const t:Int32u; const v:Int32u ) :Int32u;
571
begin
572
     Result := v shr t;
573
end;
574

575
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TRandom32WEL19937c
576

577
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
578

579
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
580

581
/////////////////////////////////////////////////////////////////////// メソッド
582

583
function TRandom32WEL19937c.CalcRandInt32u :Int32u;
584
begin
585
     with _Seed do
586
     begin
587
          Result := STATE[ state_i ] xor ( ( STATE[ state_i ] shl 07 ) and TEMPERB );
588
          Result := Result           xor ( ( Result           shl 15 ) and TEMPERC );
589
     end;
590
end;
591

592
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
593

594
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TRandom32WEL19937anew
595

596
{ http://www.ritsumei.ac.jp/~harase/WELL19937a_new.c }
597

598
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
599

600
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
601

602
/////////////////////////////////////////////////////////////////////// メソッド
603

604
function TRandom32WEL19937anew.CalcRandInt32u :Int32u;
605
begin
606
     with _Seed do
607
     begin
608
          case case_i of
609
            1: Result := STATE[ state_i ] xor ( newVM2Over and BITMASK );
610
            2: Result := STATE[ state_i ] xor ( newVM2     and BITMASK );
611
            3: Result := STATE[ state_i ] xor ( newVM2Over and BITMASK );
612
            4: Result := STATE[ state_i ] xor ( newVM2     and BITMASK );
613
            5: Result := STATE[ state_i ] xor ( newVM2Over and BITMASK );
614
            6: Result := STATE[ state_i ] xor ( newVM2     and BITMASK );
615
          else Result := 0;
616
          end;
617
     end;
618
end;
619

620
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
621

622
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
623

624
//############################################################################## □
625

626
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
627

628
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
629

630
end. //######################################################################### ■