LCG64ShiftRandom.java
001 /*
002  * Java Genetic Algorithm Library (jenetics-2.0.2).
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>
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>
039  * is followed by a non-linear transformation
040  <p>
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>
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 2.0 &mdash; <em>$Date: 2014-03-31 $</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 2.0 &mdash; <em>$Date: 2014-03-31 $</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 2.0 &mdash; <em>$Date: 2014-03-31 $</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>
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          */
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 2.0 &mdash; <em>$Date: 2014-03-31 $</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 HashBuilder.of(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 (2014-03-16 15:45)              #
612 #=============================================================================#
613 #=============================================================================#
614 # Linux 3.11.0-18-generic (amd64)                                             #
615 # java version "1.7.0_51"                                                     #
616 # Java(TM) SE Runtime Environment (build 1.7.0_51-b13)                        #
617 # Java HotSpot(TM) 64-Bit Server VM (build 24.51-b03)                         #
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.58e+07  |4267742385|
624 #=============================================================================#
625         test_name   |ntup| tsamples |psamples|  p-value |Assessment
626 #=============================================================================#
627    diehard_birthdays|   0|       100|     100|0.45039643|  PASSED
628       diehard_operm5|   0|   1000000|     100|0.59327357|  PASSED
629   diehard_rank_32x32|   0|     40000|     100|0.20883232|  PASSED
630     diehard_rank_6x8|   0|    100000|     100|0.30457399|  PASSED
631    diehard_bitstream|   0|   2097152|     100|0.24926324|  PASSED
632         diehard_opso|   0|   2097152|     100|0.37152313|  PASSED
633         diehard_oqso|   0|   2097152|     100|0.65105245|  PASSED
634          diehard_dna|   0|   2097152|     100|0.23983074|  PASSED
635 diehard_count_1s_str|   0|    256000|     100|0.96410795|  PASSED
636 diehard_count_1s_byt|   0|    256000|     100|0.76075742|  PASSED
637  diehard_parking_lot|   0|     12000|     100|0.99950785|   WEAK
638     diehard_2dsphere|   2|      8000|     100|0.31242971|  PASSED
639     diehard_3dsphere|   3|      4000|     100|0.66970487|  PASSED
640      diehard_squeeze|   0|    100000|     100|0.28098233|  PASSED
641         diehard_sums|   0|       100|     100|0.00052785|   WEAK
642         diehard_runs|   0|    100000|     100|0.09360187|  PASSED
643         diehard_runs|   0|    100000|     100|0.05307331|  PASSED
644        diehard_craps|   0|    200000|     100|0.79180066|  PASSED
645        diehard_craps|   0|    200000|     100|0.38244853|  PASSED
646  marsaglia_tsang_gcd|   0|  10000000|     100|0.92042015|  PASSED
647  marsaglia_tsang_gcd|   0|  10000000|     100|0.57740431|  PASSED
648          sts_monobit|   1|    100000|     100|0.45990409|  PASSED
649             sts_runs|   2|    100000|     100|0.90750246|  PASSED
650           sts_serial|   1|    100000|     100|0.24368584|  PASSED
651           sts_serial|   2|    100000|     100|0.96390737|  PASSED
652           sts_serial|   3|    100000|     100|0.87546907|  PASSED
653           sts_serial|   3|    100000|     100|0.76973439|  PASSED
654           sts_serial|   4|    100000|     100|0.98863010|  PASSED
655           sts_serial|   4|    100000|     100|0.86261775|  PASSED
656           sts_serial|   5|    100000|     100|0.45745558|  PASSED
657           sts_serial|   5|    100000|     100|0.35224082|  PASSED
658           sts_serial|   6|    100000|     100|0.72971604|  PASSED
659           sts_serial|   6|    100000|     100|0.32105739|  PASSED
660           sts_serial|   7|    100000|     100|0.47343631|  PASSED
661           sts_serial|   7|    100000|     100|0.51244430|  PASSED
662           sts_serial|   8|    100000|     100|0.68542330|  PASSED
663           sts_serial|   8|    100000|     100|0.92459796|  PASSED
664           sts_serial|   9|    100000|     100|0.41674031|  PASSED
665           sts_serial|   9|    100000|     100|0.79185505|  PASSED
666           sts_serial|  10|    100000|     100|0.94112938|  PASSED
667           sts_serial|  10|    100000|     100|0.72176603|  PASSED
668           sts_serial|  11|    100000|     100|0.10581871|  PASSED
669           sts_serial|  11|    100000|     100|0.41719958|  PASSED
670           sts_serial|  12|    100000|     100|0.97997651|  PASSED
671           sts_serial|  12|    100000|     100|0.78073227|  PASSED
672           sts_serial|  13|    100000|     100|0.98142093|  PASSED
673           sts_serial|  13|    100000|     100|0.91602804|  PASSED
674           sts_serial|  14|    100000|     100|0.95398159|  PASSED
675           sts_serial|  14|    100000|     100|0.73166019|  PASSED
676           sts_serial|  15|    100000|     100|0.67357983|  PASSED
677           sts_serial|  15|    100000|     100|0.83966447|  PASSED
678           sts_serial|  16|    100000|     100|0.59955079|  PASSED
679           sts_serial|  16|    100000|     100|0.60549496|  PASSED
680          rgb_bitdist|   1|    100000|     100|0.94589474|  PASSED
681          rgb_bitdist|   2|    100000|     100|0.43933033|  PASSED
682          rgb_bitdist|   3|    100000|     100|0.82309949|  PASSED
683          rgb_bitdist|   4|    100000|     100|0.78680769|  PASSED
684          rgb_bitdist|   5|    100000|     100|0.93131000|  PASSED
685          rgb_bitdist|   6|    100000|     100|0.99850203|   WEAK
686          rgb_bitdist|   7|    100000|     100|0.93754771|  PASSED
687          rgb_bitdist|   8|    100000|     100|0.88635552|  PASSED
688          rgb_bitdist|   9|    100000|     100|0.89848952|  PASSED
689          rgb_bitdist|  10|    100000|     100|0.76821791|  PASSED
690          rgb_bitdist|  11|    100000|     100|0.97139081|  PASSED
691          rgb_bitdist|  12|    100000|     100|0.08792796|  PASSED
692 rgb_minimum_distance|   2|     10000|    1000|0.68487423|  PASSED
693 rgb_minimum_distance|   3|     10000|    1000|0.37025710|  PASSED
694 rgb_minimum_distance|   4|     10000|    1000|0.98258474|  PASSED
695 rgb_minimum_distance|   5|     10000|    1000|0.19144059|  PASSED
696     rgb_permutations|   2|    100000|     100|0.87693952|  PASSED
697     rgb_permutations|   3|    100000|     100|0.41313337|  PASSED
698     rgb_permutations|   4|    100000|     100|0.18224831|  PASSED
699     rgb_permutations|   5|    100000|     100|0.59815756|  PASSED
700       rgb_lagged_sum|   0|   1000000|     100|0.67910477|  PASSED
701       rgb_lagged_sum|   1|   1000000|     100|0.60343779|  PASSED
702       rgb_lagged_sum|   2|   1000000|     100|0.28769410|  PASSED
703       rgb_lagged_sum|   3|   1000000|     100|0.78170101|  PASSED
704       rgb_lagged_sum|   4|   1000000|     100|0.99995091|   WEAK
705       rgb_lagged_sum|   5|   1000000|     100|0.31430170|  PASSED
706       rgb_lagged_sum|   6|   1000000|     100|0.07939452|  PASSED
707       rgb_lagged_sum|   7|   1000000|     100|0.38662237|  PASSED
708       rgb_lagged_sum|   8|   1000000|     100|0.46990064|  PASSED
709       rgb_lagged_sum|   9|   1000000|     100|0.76800256|  PASSED
710       rgb_lagged_sum|  10|   1000000|     100|0.43425416|  PASSED
711       rgb_lagged_sum|  11|   1000000|     100|0.02783362|  PASSED
712       rgb_lagged_sum|  12|   1000000|     100|0.06019727|  PASSED
713       rgb_lagged_sum|  13|   1000000|     100|0.81119526|  PASSED
714       rgb_lagged_sum|  14|   1000000|     100|0.95926868|  PASSED
715       rgb_lagged_sum|  15|   1000000|     100|0.88352257|  PASSED
716       rgb_lagged_sum|  16|   1000000|     100|0.87584419|  PASSED
717       rgb_lagged_sum|  17|   1000000|     100|0.64472166|  PASSED
718       rgb_lagged_sum|  18|   1000000|     100|0.56987188|  PASSED
719       rgb_lagged_sum|  19|   1000000|     100|0.64145070|  PASSED
720       rgb_lagged_sum|  20|   1000000|     100|0.78127180|  PASSED
721       rgb_lagged_sum|  21|   1000000|     100|0.54519336|  PASSED
722       rgb_lagged_sum|  22|   1000000|     100|0.23149114|  PASSED
723       rgb_lagged_sum|  23|   1000000|     100|0.72388073|  PASSED
724       rgb_lagged_sum|  24|   1000000|     100|0.65464623|  PASSED
725       rgb_lagged_sum|  25|   1000000|     100|0.54755277|  PASSED
726       rgb_lagged_sum|  26|   1000000|     100|0.32940099|  PASSED
727       rgb_lagged_sum|  27|   1000000|     100|0.76771245|  PASSED
728       rgb_lagged_sum|  28|   1000000|     100|0.59380369|  PASSED
729       rgb_lagged_sum|  29|   1000000|     100|0.23912767|  PASSED
730       rgb_lagged_sum|  30|   1000000|     100|0.80006674|  PASSED
731       rgb_lagged_sum|  31|   1000000|     100|0.66166783|  PASSED
732       rgb_lagged_sum|  32|   1000000|     100|0.83009925|  PASSED
733      rgb_kstest_test|   0|     10000|    1000|0.27652736|  PASSED
734      dab_bytedistrib|   0|  51200000|       1|0.53181874|  PASSED
735              dab_dct| 256|     50000|       1|0.00243195|   WEAK
736 Preparing to run test 207.  ntuple = 0
737         dab_filltree|  32|  15000000|       1|0.83475134|  PASSED
738         dab_filltree|  32|  15000000|       1|0.41742147|  PASSED
739 Preparing to run test 208.  ntuple = 0
740        dab_filltree2|   0|   5000000|       1|0.58540337|  PASSED
741        dab_filltree2|   1|   5000000|       1|0.06653194|  PASSED
742 Preparing to run test 209.  ntuple = 0
743         dab_monobit2|  12|  65000000|       1|0.51607890|  PASSED
744 #=============================================================================#
745 # Runtime: 0:39:19                                                            #
746 #=============================================================================#
747 */