LCG64ShiftRandom.java
001 /*
002  * Java Genetic Algorithm Library (jenetics-1.5.0).
003  * Copyright (c) 2007-2013 Franz Wilhelmstötter
004  *
005  * Licensed under the Apache License, Version 2.0 (the "License");
006  * you may not use this file except in compliance with the License.
007  * You may obtain a copy of the License at
008  *
009  *      http://www.apache.org/licenses/LICENSE-2.0
010  *
011  * Unless required by applicable law or agreed to in writing, software
012  * distributed under the License is distributed on an "AS IS" BASIS,
013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014  * See the License for the specific language governing permissions and
015  * limitations under the License.
016  *
017  * Author:
018  *    Franz Wilhelmstötter (franz.wilhelmstoetter@gmx.at)
019  */
020 package org.jenetics.util;
021 
022 import static java.lang.String.format;
023 import static java.util.Objects.requireNonNull;
024 import static org.jenetics.util.object.hashCodeOf;
025 
026 import java.io.Serializable;
027 
028 
029 /**
030  * This class implements a linear congruential PRNG with additional bit-shift
031  * transition. The base recursion
032  <p><div align="center">
033  <img
034  *     alt="r_{i+1} = (a\cdot r_i + b) \mod 2^{64}"
035  *     src="doc-files/lcg-recursion.gif"
036  * />
037  </p></div>
038  * is followed by a non-linear transformation
039  <p><div align="center">
040  <img
041  *     alt="\begin{eqnarray*}
042  *           t &=& r_i                \\
043  *           t &=& t \oplus (t >> 17) \\
044  *           t &=& t \oplus (t << 31) \\
045  *           t &=& t \oplus (t >> 8)
046  *         \end{eqnarray*}"
047  *     src="doc-files/lcg-non-linear.gif"
048  * />
049  </p></div>
050  * which destroys the lattice structure introduced by the recursion. The period
051  * of this PRNG is 2<sup>64</sup>, {@code iff} <i>b</i> is odd and <i>a</i>
052  * {@code mod} 4 = 1.
053  <p/>
054  *
055  <em>
056  * This is an re-implementation of the
057  * <a href="https://github.com/rabauke/trng4/blob/master/src/lcg64_shift.hpp">
058  * trng::lcg64_shift</a> PRNG class of the
059  * <a href="http://numbercrunch.de/trng/">TRNG</a> library created by Heiko
060  * Bauke.</em>
061  *
062  <p/>
063  <strong>Not that the base implementation of the {@code LCG64ShiftRandom}
064  * class is not thread-safe.</strong> If multiple threads requests random
065  * numbers from this class, it <i>must</i> be synchronized externally.
066  * Alternatively you can use the thread-safe implementations
067  {@link LCG64ShiftRandom.ThreadSafe} or {@link LCG64ShiftRandom.ThreadLocal}.
068  *
069  @see <a href="http://numbercrunch.de/trng/">TRNG</a>
070  @see RandomRegistry
071  *
072  @author <a href="mailto:franz.wilhelmstoetter@gmx.at">Franz Wilhelmstötter</a>
073  @since 1.1
074  @version 1.1 &mdash; <em>$Date: 2013-12-08 $</em>
075  */
076 public class LCG64ShiftRandom extends Random64 {
077 
078     private static final long serialVersionUID = 1L;
079 
080     /**
081      * Parameter class for the {@code LCG64ShiftRandom} generator, for the
082      * parameters <i>a</i> and <i>b</i> of the LC recursion
083      <i>r<sub>i+1</sub> = a · r<sub>i</sub> + b</i> mod <i>2<sup>64</sup></i>.
084      *
085      @author <a href="mailto:franz.wilhelmstoetter@gmx.at">Franz Wilhelmstötter</a>
086      @since 1.1
087      @version 1.1 &mdash; <em>$Date: 2013-12-08 $</em>
088      */
089     public static final class Param implements Serializable {
090 
091         private static final long serialVersionUID = 1L;
092 
093         /**
094          * The default PRNG parameters: a = 0xFBD19FBBC5C07FF5L; b = 1
095          */
096         public static final Param DEFAULT = new Param(0xFBD19FBBC5C07FF5L1L);
097 
098         /**
099          * LEcuyer 1 parameters: a = 0x27BB2EE687B0B0FDL; b = 1
100          */
101         public static final Param LECUYER1 = new Param(0x27BB2EE687B0B0FDL1L);
102 
103         /**
104          * LEcuyer 2 parameters: a = 0x2C6FE96EE78B6955L; b = 1
105          */
106         public static final Param LECUYER2 = new Param(0x2C6FE96EE78B6955L1L);
107 
108         /**
109          * LEcuyer 3 parameters: a = 0x369DEA0F31A53F85L; b = 1
110          */
111         public static final Param LECUYER3 = new Param(0x369DEA0F31A53F85L1L);
112 
113 
114         /**
115          * The parameter <i>a</i> of the LC recursion.
116          */
117         public final long a;
118 
119         /**
120          * The parameter <i>b</i> of the LC recursion.
121          */
122         public final long b;
123 
124         /**
125          * Create a new parameter object.
126          *
127          @param a the parameter <i>a</i> of the LC recursion.
128          @param b the parameter <i>b</i> of the LC recursion.
129          */
130         public Param(final long a, final long b) {
131             this.a = a;
132             this.b = b;
133         }
134 
135         @Override
136         public int hashCode() {
137             return 31*(int)(a^(a >>> 32)) 31*(int)(b^(b >>> 32));
138         }
139 
140         @Override
141         public boolean equals(final Object obj) {
142             if (obj == this) {
143                 return true;
144             }
145             if (!(obj instanceof Param)) {
146                 return false;
147             }
148 
149             final Param param = (Param)obj;
150             return a == param.a && b == param.b;
151         }
152 
153         @Override
154         public String toString() {
155             return format("%s[a=%d, b=%d]", getClass().getName(), a, b);
156         }
157     }
158 
159     /**
160      * This class represents a <i>thread local</i> implementation of the
161      * {@code LCG64ShiftRandom} PRNG.
162      *
163      * It's recommended to initialize the {@code RandomRegistry} the following
164      * way:
165      *
166      * [code]
167      * // Register the PRNG with the default parameters.
168      * RandomRegistry.setRandom(new LCG64ShiftRandom.ThreadLocal());
169      *
170      * // Register the PRNG with the {@code LECUYER3} parameters.
171      * RandomRegistry.setRandom(new LCG64ShiftRandom.ThreadLocal(
172      *     LCG64ShiftRandom.LECUYER3
173      * ));
174      * [/code]
175      *
176      * Be aware, that calls of the {@code setSeed(long)} method will throw an
177      * {@code UnsupportedOperationException} for <i>thread local</i> instances.
178      * [code]
179      * RandomRegistry.setRandom(new LCG64ShiftRandom.ThreadLocal());
180      *
181      * // Will throw 'UnsupportedOperationException'.
182      * RandomRegistry.getRandom().setSeed(1234);
183      * [/code]
184      *
185      @author <a href="mailto:franz.wilhelmstoetter@gmx.at">Franz Wilhelmstötter</a>
186      @since 1.1
187      @version 1.1 &mdash; <em>$Date: 2013-12-08 $</em>
188      */
189     public static class ThreadLocal
190         extends java.lang.ThreadLocal<LCG64ShiftRandom>
191     {
192         private static final long STEP_BASE = 1L << 56;
193 
194         private int _block = 0;
195         private long _seed = math.random.seed();
196 
197         private final Param _param;
198 
199         /**
200          * Create a new <i>thread local</i> instance of the
201          * {@code LCG64ShiftRandom} PRGN with the {@code DEFAULT} parameters.
202          */
203         public ThreadLocal() {
204             this(Param.DEFAULT);
205         }
206 
207         /**
208          * Create a new <i>thread local</i> instance of the
209          * {@code LCG64ShiftRandom} PRGN with the given parameters.
210          *
211          @param param the LC parameters.
212          @throws NullPointerException if the given parameters are null.
213          */
214         public ThreadLocal(final Param param) {
215             _param = requireNonNull(param, "PRNG param must not be null.");
216         }
217 
218         /**
219          * Create a new PRNG using <i>block splitting</i> for guaranteeing well
220          * distributed PRN for every thread.
221          *
222          * <p align="left">
223          <strong>Tina’s Random Number Generator Library</strong>
224          <br/>
225          <em>Chapter 2. Pseudo-random numbers for parallel Monte Carlo
226          *     simulations, Page 7</em>
227          <br/>
228          <small>Heiko Bauke</small>
229          <br/>
230          * [<a href="http://numbercrunch.de/trng/trng.pdf">
231          *  http://numbercrunch.de/trng/trng.pdf
232          *  </a>].
233          <p/>
234          */
235         @Override
236         protected synchronized LCG64ShiftRandom initialValue() {
237             if (_block > 127) {
238                 _block = 0;
239                 _seed = math.random.seed();
240             }
241 
242             final LCG64ShiftRandom random = new TLLCG64ShiftRandom(_seed, _param);
243             random.jump((_block++)*STEP_BASE);
244             return random;
245         }
246 
247     }
248 
249     private static final class TLLCG64ShiftRandom extends LCG64ShiftRandom {
250 
251         private static final long serialVersionUID = 1L;
252 
253         private final Boolean _sentry = Boolean.TRUE;
254 
255         private TLLCG64ShiftRandom(final long seed, final Param param) {
256             super(seed, param);
257         }
258 
259         @Override
260         public void setSeed(final long seed) {
261             if (_sentry != null) {
262                 throw new UnsupportedOperationException(
263                     "The 'setSeed(long)' method is not supported " +
264                     "for thread local instances."
265                 );
266             }
267         }
268 
269     }
270 
271     /**
272      * This is a <i>thread safe</i> variation of the this PRGN&mdash;by
273      * synchronizing the random number generation.
274      *
275      @author <a href="mailto:franz.wilhelmstoetter@gmx.at">Franz Wilhelmstötter</a>
276      @since 1.1
277      @version 1.1 &mdash; <em>$Date: 2013-12-08 $</em>
278      */
279     public static class ThreadSafe extends LCG64ShiftRandom {
280         private static final long serialVersionUID = 1L;
281 
282         /**
283          * Create a new PRNG instance with the given parameter and seed.
284          *
285          @param seed the seed of the PRNG.
286          @param param the parameter of the PRNG.
287          @throws NullPointerException if the given {@code param} is null.
288          */
289         public ThreadSafe(final long seed, final Param param) {
290             super(seed, param);
291         }
292 
293         /**
294          * Create a new PRNG instance with {@link Param#DEFAULT} parameter and
295          * the given seed.
296          *
297          @param seed the seed of the PRNG
298          */
299         public ThreadSafe(final long seed) {
300             this(seed, Param.DEFAULT);
301         }
302 
303         /**
304          * Create a new PRNG instance with the given parameter and a safe
305          * default seed.
306          *
307          @param param the PRNG parameter.
308          @throws NullPointerException if the given {@code param} is null.
309          */
310         public ThreadSafe(final Param param) {
311             this(math.random.seed(), param);
312         }
313 
314         /**
315          * Create a new PRNG instance with {@link Param#DEFAULT} parameter and
316          * a safe seed.
317          */
318         public ThreadSafe() {
319             this(math.random.seed(), Param.DEFAULT);
320         }
321 
322         @Override
323         public synchronized void setSeed(final long seed) {
324             super.setSeed(seed);
325         }
326 
327         @Override
328         public synchronized void reset() {
329             super.reset();
330         }
331 
332         @Override
333         public synchronized long nextLong() {
334             return super.nextLong();
335         }
336 
337         @Override
338         public synchronized void split(final int p, final int s) {
339             super.split(p, s);
340         }
341 
342         @Override
343         public synchronized void jump2(final int s) {
344             super.jump2(s);
345         }
346 
347         @Override
348         public synchronized void jump(final long step) {
349             super.jump(step);
350         }
351 
352     }
353 
354 
355 
356     private final Param _param;
357     private final long _seed;
358 
359     private long _a = 0;
360     private long _b = 0;
361     private long _r = 0;
362 
363     /**
364      * Create a new PRNG instance with {@link Param#DEFAULT} parameter and safe
365      * seed.
366      */
367     public LCG64ShiftRandom() {
368         this(math.random.seed());
369     }
370 
371     /**
372      * Create a new PRNG instance with {@link Param#DEFAULT} parameter and the
373      * given seed.
374      *
375      @param seed the seed of the PRNG
376      */
377     public LCG64ShiftRandom(final long seed) {
378         this(seed, Param.DEFAULT);
379     }
380 
381     /**
382      * Create a new PRNG instance with the given parameter and a safe seed
383      *
384      @param param the PRNG parameter.
385      @throws NullPointerException if the given {@code param} is null.
386      */
387     public LCG64ShiftRandom(final Param param) {
388         this(math.random.seed(), param);
389     }
390 
391     /**
392      * Create a new PRNG instance with the given parameter and seed.
393      *
394      @param seed the seed of the PRNG.
395      @param param the parameter of the PRNG.
396      @throws NullPointerException if the given {@code param} is null.
397      */
398     public LCG64ShiftRandom(final long seed, final Param param) {
399         _param = requireNonNull(param, "PRNG param must not be null.");
400         _seed = seed;
401 
402         _r = seed;
403         _a = param.a;
404         _b = param.b;
405     }
406 
407     /**
408      * Resets the PRNG back to the creation state.
409      */
410     public void reset() {
411         _r = _seed;
412         _a = _param.a;
413         _b = _param.b;
414     }
415 
416     @Override
417     public void setSeed(final long seed) {
418         _r = seed;
419     }
420 
421     @Override
422     public long nextLong() {
423         step();
424 
425         long t = _r;
426         t ^= t >>> 17;
427         t ^= t << 31;
428         t ^= t >>> 8;
429         return t;
430     }
431 
432     private void step() {
433         _r = _a*_r + _b;
434     }
435 
436     /**
437      * Changes the internal state of the PRNG in a way that future calls to
438      {@link #nextLong()} will generated the s<sup>th</sup> sub-stream of
439      * p<sup>th</sup> sub-streams. <i>s</i> must be within the range of
440      * {@code [0, p-1)}. This method is mainly used for <i>parallelization</i>
441      * via <i>leap-frogging</i>.
442      *
443      @param p the overall number of sub-streams
444      @param s the s<sup>th</sup> sub-stream
445      @throws IllegalArgumentException if {@code p < 1 || s >= p}.
446      */
447     public void split(final int p, final int s) {
448         if (p < 1) {
449             throw new IllegalArgumentException(format(
450                 "p must be >= 1 but was %d.", p
451             ));
452         }
453         if (s >= p) {
454             throw new IllegalArgumentException(format(
455                 "s must be < %d but was %d.", p, s
456             ));
457         }
458 
459         if (p > 1) {
460             jump(s + 1);
461             _b *= f(p, _a);
462             _a = math.pow(_a, p);
463             backward();
464         }
465     }
466 
467     /**
468      * Changes the internal state of the PRNG in such a way that the engine
469      <i>jumps</i> 2<sup>s</sup> steps ahead.
470      *
471      @param s the 2<sup>s</sup> steps to jump ahead.
472      @throws IllegalArgumentException if {@code s < 0}.
473      */
474     public void jump2(final int s) {
475         if (s < 0) {
476             throw new IllegalArgumentException(format(
477                 "s must be positive but was %d.", s
478             ));
479         }
480 
481         if (s >= Long.SIZE) {
482             throw new IllegalArgumentException(format(
483                 "The 'jump2' size must be smaller than %d but was %d.",
484                 Long.SIZE, s
485             ));
486         }
487 
488         _r = _r*math.pow(_a, 1L << s+ f(1L << s, _a)*_b;
489     }
490 
491     /**
492      * Changes the internal state of the PRNG in such a way that the engine
493      <i>jumps</i> s steps ahead.
494      *
495      @param step the steps to jump ahead.
496      @throws IllegalArgumentException if {@code s < 0}.
497      */
498     public void jump(final long step) {
499         if (step < 0) {
500             throw new IllegalArgumentException(format(
501                 "step must be positive but was %d", step
502             ));
503         }
504 
505         if (step < 16) {
506             for (int i = 0; i < step; ++i) {
507                 step();
508             }
509         else {
510             long s = step;
511             int i = 0;
512             while (s > 0) {
513                 if (s%== 1) {
514                     jump2(i);
515                 }
516                 ++i;
517                 s >>= 1;
518             }
519         }
520     }
521 
522     private void backward() {
523         for (int i = 0; i < Long.SIZE; ++i) {
524             jump2(i);
525         }
526     }
527 
528     @Override
529     public String toString() {
530         return format(
531             "%s[a=%d, b=%d, r=%d",
532             getClass().getName(), _a, _b, _r
533         );
534     }
535 
536     @Override
537     public int hashCode() {
538         return hashCodeOf(getClass())
539                 .and(_a).and(_b).and(_r)
540                 .and(_seed).and(_param).value();
541     }
542 
543     @Override
544     public boolean equals(final Object obj) {
545         if (obj == this) {
546             return true;
547         }
548         if (!(obj instanceof LCG64ShiftRandom)) {
549             return false;
550         }
551 
552         final LCG64ShiftRandom random = (LCG64ShiftRandom)obj;
553         return _a == random._a &&
554                 _b == random._b &&
555                 _r == random._r &&
556                 _seed == random._seed &&
557                 _param.equals(random._param);
558     }
559 
560     /**
561      * Compute prod(1+a^(2^i), i=0..l-1).
562      */
563     private static long g(final int l, final long a) {
564         long p = a;
565         long res = 1;
566         for (int i = 0; i < l; ++i) {
567             res *= + p;
568             p *= p;
569         }
570 
571         return res;
572     }
573 
574     /**
575      * Compute sum(a^i, i=0..s-1).
576      */
577     private static long f(final long s, final long a) {
578         long y = 0;
579 
580         if (s != 0) {
581             long e = log2Floor(s);
582             long p = a;
583 
584             for (int l = 0; l <= e; ++l) {
585                 if (((1L << l& s!= 0) {
586                     y = g(l, a+ p*y;
587                 }
588                 p *= p;
589             }
590         }
591 
592         return y;
593     }
594 
595     private static long log2Floor(final long s) {
596         long x = s;
597         long y = 0;
598 
599         while (x != 0) {
600             x >>>= 1;
601             ++y;
602         }
603 
604         return y - 1;
605     }
606 
607 }
608 
609 /*
610 #=============================================================================#
611 # Testing: org.jenetics.util.LCG64ShiftRandom (2013-11-23 20:41)              #
612 #=============================================================================#
613 #=============================================================================#
614 # Linux 3.11.0-13-generic (amd64)                                             #
615 # java version "1.7.0_45"                                                     #
616 # Java(TM) SE Runtime Environment (build 1.7.0_45-b18)                        #
617 # Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08)                         #
618 #=============================================================================#
619 #=============================================================================#
620 #            dieharder version 3.31.1 Copyright 2003 Robert G. Brown          #
621 #=============================================================================#
622    rng_name    |rands/second|   Seed   |
623 stdin_input_raw|  3.67e+07  |3767649167|
624 #=============================================================================#
625         test_name   |ntup| tsamples |psamples|  p-value |Assessment
626 #=============================================================================#
627    diehard_birthdays|   0|       100|     100|0.83520349|  PASSED
628       diehard_operm5|   0|   1000000|     100|0.87391236|  PASSED
629   diehard_rank_32x32|   0|     40000|     100|0.07976219|  PASSED
630     diehard_rank_6x8|   0|    100000|     100|0.42981789|  PASSED
631    diehard_bitstream|   0|   2097152|     100|0.79757563|  PASSED
632         diehard_opso|   0|   2097152|     100|0.68638664|  PASSED
633         diehard_oqso|   0|   2097152|     100|0.65998847|  PASSED
634          diehard_dna|   0|   2097152|     100|0.18412339|  PASSED
635 diehard_count_1s_str|   0|    256000|     100|0.39555958|  PASSED
636 diehard_count_1s_byt|   0|    256000|     100|0.91603275|  PASSED
637  diehard_parking_lot|   0|     12000|     100|0.95063855|  PASSED
638     diehard_2dsphere|   2|      8000|     100|0.52905736|  PASSED
639     diehard_3dsphere|   3|      4000|     100|0.18277316|  PASSED
640      diehard_squeeze|   0|    100000|     100|0.78483469|  PASSED
641         diehard_sums|   0|       100|     100|0.00271184|   WEAK
642         diehard_runs|   0|    100000|     100|0.44762359|  PASSED
643         diehard_runs|   0|    100000|     100|0.21132215|  PASSED
644        diehard_craps|   0|    200000|     100|0.53336477|  PASSED
645        diehard_craps|   0|    200000|     100|0.08030157|  PASSED
646  marsaglia_tsang_gcd|   0|  10000000|     100|0.67181971|  PASSED
647  marsaglia_tsang_gcd|   0|  10000000|     100|0.43140624|  PASSED
648          sts_monobit|   1|    100000|     100|0.32023966|  PASSED
649             sts_runs|   2|    100000|     100|0.00091695|   WEAK
650           sts_serial|   1|    100000|     100|0.69977162|  PASSED
651           sts_serial|   2|    100000|     100|0.78545224|  PASSED
652           sts_serial|   3|    100000|     100|0.75716228|  PASSED
653           sts_serial|   3|    100000|     100|0.79195074|  PASSED
654           sts_serial|   4|    100000|     100|0.50399468|  PASSED
655           sts_serial|   4|    100000|     100|0.85601038|  PASSED
656           sts_serial|   5|    100000|     100|0.65771919|  PASSED
657           sts_serial|   5|    100000|     100|0.81701616|  PASSED
658           sts_serial|   6|    100000|     100|0.63612434|  PASSED
659           sts_serial|   6|    100000|     100|0.93607249|  PASSED
660           sts_serial|   7|    100000|     100|0.73110875|  PASSED
661           sts_serial|   7|    100000|     100|0.94462745|  PASSED
662           sts_serial|   8|    100000|     100|0.92601118|  PASSED
663           sts_serial|   8|    100000|     100|0.89961761|  PASSED
664           sts_serial|   9|    100000|     100|0.89899814|  PASSED
665           sts_serial|   9|    100000|     100|0.61628371|  PASSED
666           sts_serial|  10|    100000|     100|0.95165791|  PASSED
667           sts_serial|  10|    100000|     100|0.71952522|  PASSED
668           sts_serial|  11|    100000|     100|0.58773760|  PASSED
669           sts_serial|  11|    100000|     100|0.53218938|  PASSED
670           sts_serial|  12|    100000|     100|0.87023296|  PASSED
671           sts_serial|  12|    100000|     100|0.56283564|  PASSED
672           sts_serial|  13|    100000|     100|0.88807034|  PASSED
673           sts_serial|  13|    100000|     100|0.96439158|  PASSED
674           sts_serial|  14|    100000|     100|0.77240143|  PASSED
675           sts_serial|  14|    100000|     100|0.60248385|  PASSED
676           sts_serial|  15|    100000|     100|0.20327599|  PASSED
677           sts_serial|  15|    100000|     100|0.16674973|  PASSED
678           sts_serial|  16|    100000|     100|0.56246015|  PASSED
679           sts_serial|  16|    100000|     100|0.92387945|  PASSED
680          rgb_bitdist|   1|    100000|     100|0.28610452|  PASSED
681          rgb_bitdist|   2|    100000|     100|0.34366590|  PASSED
682          rgb_bitdist|   3|    100000|     100|0.56240395|  PASSED
683          rgb_bitdist|   4|    100000|     100|0.01503188|  PASSED
684          rgb_bitdist|   5|    100000|     100|0.64823884|  PASSED
685          rgb_bitdist|   6|    100000|     100|0.97800621|  PASSED
686          rgb_bitdist|   7|    100000|     100|0.77808927|  PASSED
687          rgb_bitdist|   8|    100000|     100|0.94174911|  PASSED
688          rgb_bitdist|   9|    100000|     100|0.86941377|  PASSED
689          rgb_bitdist|  10|    100000|     100|0.86172575|  PASSED
690          rgb_bitdist|  11|    100000|     100|0.57297989|  PASSED
691          rgb_bitdist|  12|    100000|     100|0.49187950|  PASSED
692 rgb_minimum_distance|   2|     10000|    1000|0.92402203|  PASSED
693 rgb_minimum_distance|   3|     10000|    1000|0.95188015|  PASSED
694 rgb_minimum_distance|   4|     10000|    1000|0.78754749|  PASSED
695 rgb_minimum_distance|   5|     10000|    1000|0.90797492|  PASSED
696     rgb_permutations|   2|    100000|     100|0.84676930|  PASSED
697     rgb_permutations|   3|    100000|     100|0.58945178|  PASSED
698     rgb_permutations|   4|    100000|     100|0.99844257|   WEAK
699     rgb_permutations|   5|    100000|     100|0.82551230|  PASSED
700       rgb_lagged_sum|   0|   1000000|     100|0.60790537|  PASSED
701       rgb_lagged_sum|   1|   1000000|     100|0.67853244|  PASSED
702       rgb_lagged_sum|   2|   1000000|     100|0.35834476|  PASSED
703       rgb_lagged_sum|   3|   1000000|     100|0.97934088|  PASSED
704       rgb_lagged_sum|   4|   1000000|     100|0.43666872|  PASSED
705       rgb_lagged_sum|   5|   1000000|     100|0.50141704|  PASSED
706       rgb_lagged_sum|   6|   1000000|     100|0.48628523|  PASSED
707       rgb_lagged_sum|   7|   1000000|     100|0.97979884|  PASSED
708       rgb_lagged_sum|   8|   1000000|     100|0.29145933|  PASSED
709       rgb_lagged_sum|   9|   1000000|     100|0.93423373|  PASSED
710       rgb_lagged_sum|  10|   1000000|     100|0.99515593|   WEAK
711       rgb_lagged_sum|  11|   1000000|     100|0.19241568|  PASSED
712       rgb_lagged_sum|  12|   1000000|     100|0.89871923|  PASSED
713       rgb_lagged_sum|  13|   1000000|     100|0.50950326|  PASSED
714       rgb_lagged_sum|  14|   1000000|     100|0.82429885|  PASSED
715       rgb_lagged_sum|  15|   1000000|     100|0.82575797|  PASSED
716       rgb_lagged_sum|  16|   1000000|     100|0.67906019|  PASSED
717       rgb_lagged_sum|  17|   1000000|     100|0.20885336|  PASSED
718       rgb_lagged_sum|  18|   1000000|     100|0.77421411|  PASSED
719       rgb_lagged_sum|  19|   1000000|     100|0.56331124|  PASSED
720       rgb_lagged_sum|  20|   1000000|     100|0.43512363|  PASSED
721       rgb_lagged_sum|  21|   1000000|     100|0.18975200|  PASSED
722       rgb_lagged_sum|  22|   1000000|     100|0.35461641|  PASSED
723       rgb_lagged_sum|  23|   1000000|     100|0.49169077|  PASSED
724       rgb_lagged_sum|  24|   1000000|     100|0.72182150|  PASSED
725       rgb_lagged_sum|  25|   1000000|     100|0.23814042|  PASSED
726       rgb_lagged_sum|  26|   1000000|     100|0.47139652|  PASSED
727       rgb_lagged_sum|  27|   1000000|     100|0.88085034|  PASSED
728       rgb_lagged_sum|  28|   1000000|     100|0.91676124|  PASSED
729       rgb_lagged_sum|  29|   1000000|     100|0.68877827|  PASSED
730       rgb_lagged_sum|  30|   1000000|     100|0.94088750|  PASSED
731       rgb_lagged_sum|  31|   1000000|     100|0.85483692|  PASSED
732       rgb_lagged_sum|  32|   1000000|     100|0.81745815|  PASSED
733      rgb_kstest_test|   0|     10000|    1000|0.40909996|  PASSED
734      dab_bytedistrib|   0|  51200000|       1|0.10967598|  PASSED
735              dab_dct| 256|     50000|       1|0.63770285|  PASSED
736 Preparing to run test 207.  ntuple = 0
737         dab_filltree|  32|  15000000|       1|0.37355121|  PASSED
738         dab_filltree|  32|  15000000|       1|0.85564309|  PASSED
739 Preparing to run test 208.  ntuple = 0
740        dab_filltree2|   0|   5000000|       1|0.74798291|  PASSED
741        dab_filltree2|   1|   5000000|       1|0.99245351|  PASSED
742 Preparing to run test 209.  ntuple = 0
743         dab_monobit2|  12|  65000000|       1|0.49612336|  PASSED
744 #=============================================================================#
745 # Runtime: 0:38:01                                                            #
746 #=============================================================================#
747 */