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