SHARE
TWEET

Retest run of BigCrush, Test#9 for pcg32

imneme Aug 22nd, 2017 (edited) 94 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. This is a retest run of BigCrush, Test#9 for pcg32, repeating 20 times
  2.  
  3. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  4.                  Starting BigCrush
  5.                  Version: TestU01 1.2.3
  6. xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  7.  
  8.  
  9. ***********************************************************
  10. Test smarsa_CollisionOver calling smultin_MultinomialOver
  11.  
  12. ***********************************************************
  13. HOST = xxxxxx, Linux
  14.  
  15. pcg32
  16.  
  17.  
  18. smultin_MultinomialOver test:
  19. -----------------------------------------------
  20.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  21.        Sparse =   TRUE
  22.  
  23.        GenerCell = smultin_GenerCellSerial
  24.        Number of cells = d^t =      4398046511104
  25.        Expected number per cell =  1 /  219902.33
  26.        EColl = n^2 / (2k) =  45.47473509
  27.        Hashing =   TRUE
  28.  
  29.        Collision test
  30.  
  31.        CollisionOver:   density = n / k =  1 /  219902.33
  32.        Expected number of collisions = Mu =      45.47
  33.  
  34.  
  35. -----------------------------------------------
  36. Results of CollisionOver test:
  37.  
  38. POISSON approximation                 :
  39. Expected number of collisions = N*Mu  :     1364.24
  40. Observed number of collisions         :     1423
  41. p-value of test                       :    0.06
  42.  
  43. -----------------------------
  44. Total number of cells containing j balls
  45.  
  46.   j =  0                              :  131940795334543
  47.   j =  1                              :        599997154
  48.   j =  2                              :             1423
  49.   j =  3                              :                0
  50.   j =  4                              :                0
  51.   j =  5                              :                0
  52.  
  53. -----------------------------------------------
  54. CPU time used                    :  00:04:03.18
  55.  
  56. Generator state:
  57.  
  58.  
  59.  
  60.  
  61. ***********************************************************
  62. Test smarsa_CollisionOver calling smultin_MultinomialOver
  63.  
  64. ***********************************************************
  65. HOST = xxxxxx, Linux
  66.  
  67. pcg32
  68.  
  69.  
  70. smultin_MultinomialOver test:
  71. -----------------------------------------------
  72.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  73.        Sparse =   TRUE
  74.  
  75.        GenerCell = smultin_GenerCellSerial
  76.        Number of cells = d^t =      4398046511104
  77.        Expected number per cell =  1 /  219902.33
  78.        EColl = n^2 / (2k) =  45.47473509
  79.        Hashing =   TRUE
  80.  
  81.        Collision test
  82.  
  83.        CollisionOver:   density = n / k =  1 /  219902.33
  84.        Expected number of collisions = Mu =      45.47
  85.  
  86.  
  87. -----------------------------------------------
  88. Results of CollisionOver test:
  89.  
  90. POISSON approximation                 :
  91. Expected number of collisions = N*Mu  :     1364.24
  92. Observed number of collisions         :     1404
  93. p-value of test                       :    0.14
  94.  
  95. -----------------------------
  96. Total number of cells containing j balls
  97.  
  98.   j =  0                              :  131940795334524
  99.   j =  1                              :        599997192
  100.   j =  2                              :             1404
  101.   j =  3                              :                0
  102.   j =  4                              :                0
  103.   j =  5                              :                0
  104.  
  105. -----------------------------------------------
  106. CPU time used                    :  00:04:03.99
  107.  
  108. Generator state:
  109.  
  110.  
  111.  
  112.  
  113. ***********************************************************
  114. Test smarsa_CollisionOver calling smultin_MultinomialOver
  115.  
  116. ***********************************************************
  117. HOST = xxxxxx, Linux
  118.  
  119. pcg32
  120.  
  121.  
  122. smultin_MultinomialOver test:
  123. -----------------------------------------------
  124.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  125.        Sparse =   TRUE
  126.  
  127.        GenerCell = smultin_GenerCellSerial
  128.        Number of cells = d^t =      4398046511104
  129.        Expected number per cell =  1 /  219902.33
  130.        EColl = n^2 / (2k) =  45.47473509
  131.        Hashing =   TRUE
  132.  
  133.        Collision test
  134.  
  135.        CollisionOver:   density = n / k =  1 /  219902.33
  136.        Expected number of collisions = Mu =      45.47
  137.  
  138.  
  139. -----------------------------------------------
  140. Results of CollisionOver test:
  141.  
  142. POISSON approximation                 :
  143. Expected number of collisions = N*Mu  :     1364.24
  144. Observed number of collisions         :     1285
  145. p-value of test                       :    0.98
  146.  
  147. -----------------------------
  148. Total number of cells containing j balls
  149.  
  150.   j =  0                              :  131940795334405
  151.   j =  1                              :        599997430
  152.   j =  2                              :             1285
  153.   j =  3                              :                0
  154.   j =  4                              :                0
  155.   j =  5                              :                0
  156.  
  157. -----------------------------------------------
  158. CPU time used                    :  00:04:30.50
  159.  
  160. Generator state:
  161.  
  162.  
  163.  
  164.  
  165. ***********************************************************
  166. Test smarsa_CollisionOver calling smultin_MultinomialOver
  167.  
  168. ***********************************************************
  169. HOST = xxxxxx, Linux
  170.  
  171. pcg32
  172.  
  173.  
  174. smultin_MultinomialOver test:
  175. -----------------------------------------------
  176.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  177.        Sparse =   TRUE
  178.  
  179.        GenerCell = smultin_GenerCellSerial
  180.        Number of cells = d^t =      4398046511104
  181.        Expected number per cell =  1 /  219902.33
  182.        EColl = n^2 / (2k) =  45.47473509
  183.        Hashing =   TRUE
  184.  
  185.        Collision test
  186.  
  187.        CollisionOver:   density = n / k =  1 /  219902.33
  188.        Expected number of collisions = Mu =      45.47
  189.  
  190.  
  191. -----------------------------------------------
  192. Results of CollisionOver test:
  193.  
  194. POISSON approximation                 :
  195. Expected number of collisions = N*Mu  :     1364.24
  196. Observed number of collisions         :     1333
  197. p-value of test                       :    0.80
  198.  
  199. -----------------------------
  200. Total number of cells containing j balls
  201.  
  202.   j =  0                              :  131940795334453
  203.   j =  1                              :        599997334
  204.   j =  2                              :             1333
  205.   j =  3                              :                0
  206.   j =  4                              :                0
  207.   j =  5                              :                0
  208.  
  209. -----------------------------------------------
  210. CPU time used                    :  00:04:06.79
  211.  
  212. Generator state:
  213.  
  214.  
  215.  
  216.  
  217. ***********************************************************
  218. Test smarsa_CollisionOver calling smultin_MultinomialOver
  219.  
  220. ***********************************************************
  221. HOST = xxxxxx, Linux
  222.  
  223. pcg32
  224.  
  225.  
  226. smultin_MultinomialOver test:
  227. -----------------------------------------------
  228.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  229.        Sparse =   TRUE
  230.  
  231.        GenerCell = smultin_GenerCellSerial
  232.        Number of cells = d^t =      4398046511104
  233.        Expected number per cell =  1 /  219902.33
  234.        EColl = n^2 / (2k) =  45.47473509
  235.        Hashing =   TRUE
  236.  
  237.        Collision test
  238.  
  239.        CollisionOver:   density = n / k =  1 /  219902.33
  240.        Expected number of collisions = Mu =      45.47
  241.  
  242.  
  243. -----------------------------------------------
  244. Results of CollisionOver test:
  245.  
  246. POISSON approximation                 :
  247. Expected number of collisions = N*Mu  :     1364.24
  248. Observed number of collisions         :     1301
  249. p-value of test                       :    0.96
  250.  
  251. -----------------------------
  252. Total number of cells containing j balls
  253.  
  254.   j =  0                              :  131940795334421
  255.   j =  1                              :        599997398
  256.   j =  2                              :             1301
  257.   j =  3                              :                0
  258.   j =  4                              :                0
  259.   j =  5                              :                0
  260.  
  261. -----------------------------------------------
  262. CPU time used                    :  00:04:10.91
  263.  
  264. Generator state:
  265.  
  266.  
  267.  
  268.  
  269. ***********************************************************
  270. Test smarsa_CollisionOver calling smultin_MultinomialOver
  271.  
  272. ***********************************************************
  273. HOST = xxxxxx, Linux
  274.  
  275. pcg32
  276.  
  277.  
  278. smultin_MultinomialOver test:
  279. -----------------------------------------------
  280.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  281.        Sparse =   TRUE
  282.  
  283.        GenerCell = smultin_GenerCellSerial
  284.        Number of cells = d^t =      4398046511104
  285.        Expected number per cell =  1 /  219902.33
  286.        EColl = n^2 / (2k) =  45.47473509
  287.        Hashing =   TRUE
  288.  
  289.        Collision test
  290.  
  291.        CollisionOver:   density = n / k =  1 /  219902.33
  292.        Expected number of collisions = Mu =      45.47
  293.  
  294.  
  295. -----------------------------------------------
  296. Results of CollisionOver test:
  297.  
  298. POISSON approximation                 :
  299. Expected number of collisions = N*Mu  :     1364.24
  300. Observed number of collisions         :     1369
  301. p-value of test                       :    0.45
  302.  
  303. -----------------------------
  304. Total number of cells containing j balls
  305.  
  306.   j =  0                              :  131940795334489
  307.   j =  1                              :        599997262
  308.   j =  2                              :             1369
  309.   j =  3                              :                0
  310.   j =  4                              :                0
  311.   j =  5                              :                0
  312.  
  313. -----------------------------------------------
  314. CPU time used                    :  00:04:11.01
  315.  
  316. Generator state:
  317.  
  318.  
  319.  
  320.  
  321. ***********************************************************
  322. Test smarsa_CollisionOver calling smultin_MultinomialOver
  323.  
  324. ***********************************************************
  325. HOST = xxxxxx, Linux
  326.  
  327. pcg32
  328.  
  329.  
  330. smultin_MultinomialOver test:
  331. -----------------------------------------------
  332.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  333.        Sparse =   TRUE
  334.  
  335.        GenerCell = smultin_GenerCellSerial
  336.        Number of cells = d^t =      4398046511104
  337.        Expected number per cell =  1 /  219902.33
  338.        EColl = n^2 / (2k) =  45.47473509
  339.        Hashing =   TRUE
  340.  
  341.        Collision test
  342.  
  343.        CollisionOver:   density = n / k =  1 /  219902.33
  344.        Expected number of collisions = Mu =      45.47
  345.  
  346.  
  347. -----------------------------------------------
  348. Results of CollisionOver test:
  349.  
  350. POISSON approximation                 :
  351. Expected number of collisions = N*Mu  :     1364.24
  352. Observed number of collisions         :     1383
  353. p-value of test                       :    0.31
  354.  
  355. -----------------------------
  356. Total number of cells containing j balls
  357.  
  358.   j =  0                              :  131940795334503
  359.   j =  1                              :        599997234
  360.   j =  2                              :             1383
  361.   j =  3                              :                0
  362.   j =  4                              :                0
  363.   j =  5                              :                0
  364.  
  365. -----------------------------------------------
  366. CPU time used                    :  00:04:09.30
  367.  
  368. Generator state:
  369.  
  370.  
  371.  
  372.  
  373. ***********************************************************
  374. Test smarsa_CollisionOver calling smultin_MultinomialOver
  375.  
  376. ***********************************************************
  377. HOST = xxxxxx, Linux
  378.  
  379. pcg32
  380.  
  381.  
  382. smultin_MultinomialOver test:
  383. -----------------------------------------------
  384.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  385.        Sparse =   TRUE
  386.  
  387.        GenerCell = smultin_GenerCellSerial
  388.        Number of cells = d^t =      4398046511104
  389.        Expected number per cell =  1 /  219902.33
  390.        EColl = n^2 / (2k) =  45.47473509
  391.        Hashing =   TRUE
  392.  
  393.        Collision test
  394.  
  395.        CollisionOver:   density = n / k =  1 /  219902.33
  396.        Expected number of collisions = Mu =      45.47
  397.  
  398.  
  399. -----------------------------------------------
  400. Results of CollisionOver test:
  401.  
  402. POISSON approximation                 :
  403. Expected number of collisions = N*Mu  :     1364.24
  404. Observed number of collisions         :     1397
  405. p-value of test                       :    0.19
  406.  
  407. -----------------------------
  408. Total number of cells containing j balls
  409.  
  410.   j =  0                              :  131940795334517
  411.   j =  1                              :        599997206
  412.   j =  2                              :             1397
  413.   j =  3                              :                0
  414.   j =  4                              :                0
  415.   j =  5                              :                0
  416.  
  417. -----------------------------------------------
  418. CPU time used                    :  00:03:58.00
  419.  
  420. Generator state:
  421.  
  422.  
  423.  
  424.  
  425. ***********************************************************
  426. Test smarsa_CollisionOver calling smultin_MultinomialOver
  427.  
  428. ***********************************************************
  429. HOST = xxxxxx, Linux
  430.  
  431. pcg32
  432.  
  433.  
  434. smultin_MultinomialOver test:
  435. -----------------------------------------------
  436.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  437.        Sparse =   TRUE
  438.  
  439.        GenerCell = smultin_GenerCellSerial
  440.        Number of cells = d^t =      4398046511104
  441.        Expected number per cell =  1 /  219902.33
  442.        EColl = n^2 / (2k) =  45.47473509
  443.        Hashing =   TRUE
  444.  
  445.        Collision test
  446.  
  447.        CollisionOver:   density = n / k =  1 /  219902.33
  448.        Expected number of collisions = Mu =      45.47
  449.  
  450.  
  451. -----------------------------------------------
  452. Results of CollisionOver test:
  453.  
  454. POISSON approximation                 :
  455. Expected number of collisions = N*Mu  :     1364.24
  456. Observed number of collisions         :     1307
  457. p-value of test                       :    0.94
  458.  
  459. -----------------------------
  460. Total number of cells containing j balls
  461.  
  462.   j =  0                              :  131940795334427
  463.   j =  1                              :        599997386
  464.   j =  2                              :             1307
  465.   j =  3                              :                0
  466.   j =  4                              :                0
  467.   j =  5                              :                0
  468.  
  469. -----------------------------------------------
  470. CPU time used                    :  00:04:02.15
  471.  
  472. Generator state:
  473.  
  474.  
  475.  
  476.  
  477. ***********************************************************
  478. Test smarsa_CollisionOver calling smultin_MultinomialOver
  479.  
  480. ***********************************************************
  481. HOST = xxxxxx, Linux
  482.  
  483. pcg32
  484.  
  485.  
  486. smultin_MultinomialOver test:
  487. -----------------------------------------------
  488.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  489.        Sparse =   TRUE
  490.  
  491.        GenerCell = smultin_GenerCellSerial
  492.        Number of cells = d^t =      4398046511104
  493.        Expected number per cell =  1 /  219902.33
  494.        EColl = n^2 / (2k) =  45.47473509
  495.        Hashing =   TRUE
  496.  
  497.        Collision test
  498.  
  499.        CollisionOver:   density = n / k =  1 /  219902.33
  500.        Expected number of collisions = Mu =      45.47
  501.  
  502.  
  503. -----------------------------------------------
  504. Results of CollisionOver test:
  505.  
  506. POISSON approximation                 :
  507. Expected number of collisions = N*Mu  :     1364.24
  508. Observed number of collisions         :     1346
  509. p-value of test                       :    0.68
  510.  
  511. -----------------------------
  512. Total number of cells containing j balls
  513.  
  514.   j =  0                              :  131940795334466
  515.   j =  1                              :        599997308
  516.   j =  2                              :             1346
  517.   j =  3                              :                0
  518.   j =  4                              :                0
  519.   j =  5                              :                0
  520.  
  521. -----------------------------------------------
  522. CPU time used                    :  00:04:02.00
  523.  
  524. Generator state:
  525.  
  526.  
  527.  
  528.  
  529. ***********************************************************
  530. Test smarsa_CollisionOver calling smultin_MultinomialOver
  531.  
  532. ***********************************************************
  533. HOST = xxxxxx, Linux
  534.  
  535. pcg32
  536.  
  537.  
  538. smultin_MultinomialOver test:
  539. -----------------------------------------------
  540.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  541.        Sparse =   TRUE
  542.  
  543.        GenerCell = smultin_GenerCellSerial
  544.        Number of cells = d^t =      4398046511104
  545.        Expected number per cell =  1 /  219902.33
  546.        EColl = n^2 / (2k) =  45.47473509
  547.        Hashing =   TRUE
  548.  
  549.        Collision test
  550.  
  551.        CollisionOver:   density = n / k =  1 /  219902.33
  552.        Expected number of collisions = Mu =      45.47
  553.  
  554.  
  555. -----------------------------------------------
  556. Results of CollisionOver test:
  557.  
  558. POISSON approximation                 :
  559. Expected number of collisions = N*Mu  :     1364.24
  560. Observed number of collisions         :     1306
  561. p-value of test                       :    0.94
  562.  
  563. -----------------------------
  564. Total number of cells containing j balls
  565.  
  566.   j =  0                              :  131940795334426
  567.   j =  1                              :        599997388
  568.   j =  2                              :             1306
  569.   j =  3                              :                0
  570.   j =  4                              :                0
  571.   j =  5                              :                0
  572.  
  573. -----------------------------------------------
  574. CPU time used                    :  00:03:57.86
  575.  
  576. Generator state:
  577.  
  578.  
  579.  
  580.  
  581. ***********************************************************
  582. Test smarsa_CollisionOver calling smultin_MultinomialOver
  583.  
  584. ***********************************************************
  585. HOST = xxxxxx, Linux
  586.  
  587. pcg32
  588.  
  589.  
  590. smultin_MultinomialOver test:
  591. -----------------------------------------------
  592.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  593.        Sparse =   TRUE
  594.  
  595.        GenerCell = smultin_GenerCellSerial
  596.        Number of cells = d^t =      4398046511104
  597.        Expected number per cell =  1 /  219902.33
  598.        EColl = n^2 / (2k) =  45.47473509
  599.        Hashing =   TRUE
  600.  
  601.        Collision test
  602.  
  603.        CollisionOver:   density = n / k =  1 /  219902.33
  604.        Expected number of collisions = Mu =      45.47
  605.  
  606.  
  607. -----------------------------------------------
  608. Results of CollisionOver test:
  609.  
  610. POISSON approximation                 :
  611. Expected number of collisions = N*Mu  :     1364.24
  612. Observed number of collisions         :     1412
  613. p-value of test                       :    0.10
  614.  
  615. -----------------------------
  616. Total number of cells containing j balls
  617.  
  618.   j =  0                              :  131940795334532
  619.   j =  1                              :        599997176
  620.   j =  2                              :             1412
  621.   j =  3                              :                0
  622.   j =  4                              :                0
  623.   j =  5                              :                0
  624.  
  625. -----------------------------------------------
  626. CPU time used                    :  00:04:12.44
  627.  
  628. Generator state:
  629.  
  630.  
  631.  
  632.  
  633. ***********************************************************
  634. Test smarsa_CollisionOver calling smultin_MultinomialOver
  635.  
  636. ***********************************************************
  637. HOST = xxxxxx, Linux
  638.  
  639. pcg32
  640.  
  641.  
  642. smultin_MultinomialOver test:
  643. -----------------------------------------------
  644.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  645.        Sparse =   TRUE
  646.  
  647.        GenerCell = smultin_GenerCellSerial
  648.        Number of cells = d^t =      4398046511104
  649.        Expected number per cell =  1 /  219902.33
  650.        EColl = n^2 / (2k) =  45.47473509
  651.        Hashing =   TRUE
  652.  
  653.        Collision test
  654.  
  655.        CollisionOver:   density = n / k =  1 /  219902.33
  656.        Expected number of collisions = Mu =      45.47
  657.  
  658.  
  659. -----------------------------------------------
  660. Results of CollisionOver test:
  661.  
  662. POISSON approximation                 :
  663. Expected number of collisions = N*Mu  :     1364.24
  664. Observed number of collisions         :     1421
  665. p-value of test                       :    0.06
  666.  
  667. -----------------------------
  668. Total number of cells containing j balls
  669.  
  670.   j =  0                              :  131940795334541
  671.   j =  1                              :        599997158
  672.   j =  2                              :             1421
  673.   j =  3                              :                0
  674.   j =  4                              :                0
  675.   j =  5                              :                0
  676.  
  677. -----------------------------------------------
  678. CPU time used                    :  00:03:57.75
  679.  
  680. Generator state:
  681.  
  682.  
  683.  
  684.  
  685. ***********************************************************
  686. Test smarsa_CollisionOver calling smultin_MultinomialOver
  687.  
  688. ***********************************************************
  689. HOST = xxxxxx, Linux
  690.  
  691. pcg32
  692.  
  693.  
  694. smultin_MultinomialOver test:
  695. -----------------------------------------------
  696.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  697.        Sparse =   TRUE
  698.  
  699.        GenerCell = smultin_GenerCellSerial
  700.        Number of cells = d^t =      4398046511104
  701.        Expected number per cell =  1 /  219902.33
  702.        EColl = n^2 / (2k) =  45.47473509
  703.        Hashing =   TRUE
  704.  
  705.        Collision test
  706.  
  707.        CollisionOver:   density = n / k =  1 /  219902.33
  708.        Expected number of collisions = Mu =      45.47
  709.  
  710.  
  711. -----------------------------------------------
  712. Results of CollisionOver test:
  713.  
  714. POISSON approximation                 :
  715. Expected number of collisions = N*Mu  :     1364.24
  716. Observed number of collisions         :     1408
  717. p-value of test                       :    0.12
  718.  
  719. -----------------------------
  720. Total number of cells containing j balls
  721.  
  722.   j =  0                              :  131940795334528
  723.   j =  1                              :        599997184
  724.   j =  2                              :             1408
  725.   j =  3                              :                0
  726.   j =  4                              :                0
  727.   j =  5                              :                0
  728.  
  729. -----------------------------------------------
  730. CPU time used                    :  00:04:00.65
  731.  
  732. Generator state:
  733.  
  734.  
  735.  
  736.  
  737. ***********************************************************
  738. Test smarsa_CollisionOver calling smultin_MultinomialOver
  739.  
  740. ***********************************************************
  741. HOST = xxxxxx, Linux
  742.  
  743. pcg32
  744.  
  745.  
  746. smultin_MultinomialOver test:
  747. -----------------------------------------------
  748.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  749.        Sparse =   TRUE
  750.  
  751.        GenerCell = smultin_GenerCellSerial
  752.        Number of cells = d^t =      4398046511104
  753.        Expected number per cell =  1 /  219902.33
  754.        EColl = n^2 / (2k) =  45.47473509
  755.        Hashing =   TRUE
  756.  
  757.        Collision test
  758.  
  759.        CollisionOver:   density = n / k =  1 /  219902.33
  760.        Expected number of collisions = Mu =      45.47
  761.  
  762.  
  763. -----------------------------------------------
  764. Results of CollisionOver test:
  765.  
  766. POISSON approximation                 :
  767. Expected number of collisions = N*Mu  :     1364.24
  768. Observed number of collisions         :     1369
  769. p-value of test                       :    0.45
  770.  
  771. -----------------------------
  772. Total number of cells containing j balls
  773.  
  774.   j =  0                              :  131940795334489
  775.   j =  1                              :        599997262
  776.   j =  2                              :             1369
  777.   j =  3                              :                0
  778.   j =  4                              :                0
  779.   j =  5                              :                0
  780.  
  781. -----------------------------------------------
  782. CPU time used                    :  00:04:02.19
  783.  
  784. Generator state:
  785.  
  786.  
  787.  
  788.  
  789. ***********************************************************
  790. Test smarsa_CollisionOver calling smultin_MultinomialOver
  791.  
  792. ***********************************************************
  793. HOST = xxxxxx, Linux
  794.  
  795. pcg32
  796.  
  797.  
  798. smultin_MultinomialOver test:
  799. -----------------------------------------------
  800.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  801.        Sparse =   TRUE
  802.  
  803.        GenerCell = smultin_GenerCellSerial
  804.        Number of cells = d^t =      4398046511104
  805.        Expected number per cell =  1 /  219902.33
  806.        EColl = n^2 / (2k) =  45.47473509
  807.        Hashing =   TRUE
  808.  
  809.        Collision test
  810.  
  811.        CollisionOver:   density = n / k =  1 /  219902.33
  812.        Expected number of collisions = Mu =      45.47
  813.  
  814.  
  815. -----------------------------------------------
  816. Results of CollisionOver test:
  817.  
  818. POISSON approximation                 :
  819. Expected number of collisions = N*Mu  :     1364.24
  820. Observed number of collisions         :     1352
  821. p-value of test                       :    0.62
  822.  
  823. -----------------------------
  824. Total number of cells containing j balls
  825.  
  826.   j =  0                              :  131940795334472
  827.   j =  1                              :        599997296
  828.   j =  2                              :             1352
  829.   j =  3                              :                0
  830.   j =  4                              :                0
  831.   j =  5                              :                0
  832.  
  833. -----------------------------------------------
  834. CPU time used                    :  00:04:02.98
  835.  
  836. Generator state:
  837.  
  838.  
  839.  
  840.  
  841. ***********************************************************
  842. Test smarsa_CollisionOver calling smultin_MultinomialOver
  843.  
  844. ***********************************************************
  845. HOST = xxxxxx, Linux
  846.  
  847. pcg32
  848.  
  849.  
  850. smultin_MultinomialOver test:
  851. -----------------------------------------------
  852.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  853.        Sparse =   TRUE
  854.  
  855.        GenerCell = smultin_GenerCellSerial
  856.        Number of cells = d^t =      4398046511104
  857.        Expected number per cell =  1 /  219902.33
  858.        EColl = n^2 / (2k) =  45.47473509
  859.        Hashing =   TRUE
  860.  
  861.        Collision test
  862.  
  863.        CollisionOver:   density = n / k =  1 /  219902.33
  864.        Expected number of collisions = Mu =      45.47
  865.  
  866.  
  867. -----------------------------------------------
  868. Results of CollisionOver test:
  869.  
  870. POISSON approximation                 :
  871. Expected number of collisions = N*Mu  :     1364.24
  872. Observed number of collisions         :     1432
  873. p-value of test                       :    0.04
  874.  
  875. -----------------------------
  876. Total number of cells containing j balls
  877.  
  878.   j =  0                              :  131940795334552
  879.   j =  1                              :        599997136
  880.   j =  2                              :             1432
  881.   j =  3                              :                0
  882.   j =  4                              :                0
  883.   j =  5                              :                0
  884.  
  885. -----------------------------------------------
  886. CPU time used                    :  00:04:30.13
  887.  
  888. Generator state:
  889.  
  890.  
  891.  
  892.  
  893. ***********************************************************
  894. Test smarsa_CollisionOver calling smultin_MultinomialOver
  895.  
  896. ***********************************************************
  897. HOST = xxxxxx, Linux
  898.  
  899. pcg32
  900.  
  901.  
  902. smultin_MultinomialOver test:
  903. -----------------------------------------------
  904.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  905.        Sparse =   TRUE
  906.  
  907.        GenerCell = smultin_GenerCellSerial
  908.        Number of cells = d^t =      4398046511104
  909.        Expected number per cell =  1 /  219902.33
  910.        EColl = n^2 / (2k) =  45.47473509
  911.        Hashing =   TRUE
  912.  
  913.        Collision test
  914.  
  915.        CollisionOver:   density = n / k =  1 /  219902.33
  916.        Expected number of collisions = Mu =      45.47
  917.  
  918.  
  919. -----------------------------------------------
  920. Results of CollisionOver test:
  921.  
  922. POISSON approximation                 :
  923. Expected number of collisions = N*Mu  :     1364.24
  924. Observed number of collisions         :     1301
  925. p-value of test                       :    0.96
  926.  
  927. -----------------------------
  928. Total number of cells containing j balls
  929.  
  930.   j =  0                              :  131940795334421
  931.   j =  1                              :        599997398
  932.   j =  2                              :             1301
  933.   j =  3                              :                0
  934.   j =  4                              :                0
  935.   j =  5                              :                0
  936.  
  937. -----------------------------------------------
  938. CPU time used                    :  00:04:02.31
  939.  
  940. Generator state:
  941.  
  942.  
  943.  
  944.  
  945. ***********************************************************
  946. Test smarsa_CollisionOver calling smultin_MultinomialOver
  947.  
  948. ***********************************************************
  949. HOST = xxxxxx, Linux
  950.  
  951. pcg32
  952.  
  953.  
  954. smultin_MultinomialOver test:
  955. -----------------------------------------------
  956.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  957.        Sparse =   TRUE
  958.  
  959.        GenerCell = smultin_GenerCellSerial
  960.        Number of cells = d^t =      4398046511104
  961.        Expected number per cell =  1 /  219902.33
  962.        EColl = n^2 / (2k) =  45.47473509
  963.        Hashing =   TRUE
  964.  
  965.        Collision test
  966.  
  967.        CollisionOver:   density = n / k =  1 /  219902.33
  968.        Expected number of collisions = Mu =      45.47
  969.  
  970.  
  971. -----------------------------------------------
  972. Results of CollisionOver test:
  973.  
  974. POISSON approximation                 :
  975. Expected number of collisions = N*Mu  :     1364.24
  976. Observed number of collisions         :     1389
  977. p-value of test                       :    0.25
  978.  
  979. -----------------------------
  980. Total number of cells containing j balls
  981.  
  982.   j =  0                              :  131940795334509
  983.   j =  1                              :        599997222
  984.   j =  2                              :             1389
  985.   j =  3                              :                0
  986.   j =  4                              :                0
  987.   j =  5                              :                0
  988.  
  989. -----------------------------------------------
  990. CPU time used                    :  00:03:59.11
  991.  
  992. Generator state:
  993.  
  994.  
  995.  
  996.  
  997. ***********************************************************
  998. Test smarsa_CollisionOver calling smultin_MultinomialOver
  999.  
  1000. ***********************************************************
  1001. HOST = xxxxxx, Linux
  1002.  
  1003. pcg32
  1004.  
  1005.  
  1006. smultin_MultinomialOver test:
  1007. -----------------------------------------------
  1008.    N = 30,  n = 20000000,  r =  0,   d =    8,   t = 14,
  1009.        Sparse =   TRUE
  1010.  
  1011.        GenerCell = smultin_GenerCellSerial
  1012.        Number of cells = d^t =      4398046511104
  1013.        Expected number per cell =  1 /  219902.33
  1014.        EColl = n^2 / (2k) =  45.47473509
  1015.        Hashing =   TRUE
  1016.  
  1017.        Collision test
  1018.  
  1019.        CollisionOver:   density = n / k =  1 /  219902.33
  1020.        Expected number of collisions = Mu =      45.47
  1021.  
  1022.  
  1023. -----------------------------------------------
  1024. Results of CollisionOver test:
  1025.  
  1026. POISSON approximation                 :
  1027. Expected number of collisions = N*Mu  :     1364.24
  1028. Observed number of collisions         :     1323
  1029. p-value of test                       :    0.87
  1030.  
  1031. -----------------------------
  1032. Total number of cells containing j balls
  1033.  
  1034.   j =  0                              :  131940795334443
  1035.   j =  1                              :        599997354
  1036.   j =  2                              :             1323
  1037.   j =  3                              :                0
  1038.   j =  4                              :                0
  1039.   j =  5                              :                0
  1040.  
  1041. -----------------------------------------------
  1042. CPU time used                    :  00:04:32.17
  1043.  
  1044. Generator state:
  1045.  
  1046.  
  1047.  
  1048.  
  1049.  
  1050. ========= Summary results of BigCrush =========
  1051.  
  1052.  Version:          TestU01 1.2.3
  1053.  Generator:        pcg32
  1054.  Number of statistics:  20
  1055.  Total CPU time:   01:22:35.53
  1056.  
  1057.  All tests were passed
  1058.  
  1059.  
  1060.  
  1061.  - pvalues: 0.05811, 0.144, 0.9842, 0.797, 0.9561, 0.4523, 0.3093, 0.1909, 0.9385, 0.6832, 0.9418, 0.1008, 0.06458, 0.1211, 0.4523, 0.6231, 0.03508, 0.9561, 0.2548, 0.8652
  1062.  - pvalue stats: average 0.4964, stddev 0.1268
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top