SHARE
TWEET

Retest run of BigCrush, Test#11 for splitmix

imneme Aug 22nd, 2017 103 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. This is a retest run of BigCrush, Test#11 for splitmix [High bits] [Byte Reversed], 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. splitmix [High bits] [Byte Reversed]
  16.  
  17.  
  18. smultin_MultinomialOver test:
  19. -----------------------------------------------
  20.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1380
  41. p-value of test                       :    0.34
  42.  
  43. -----------------------------
  44. Total number of cells containing j balls
  45.  
  46.   j =  0                              :  131940795334500
  47.   j =  1                              :        599997240
  48.   j =  2                              :             1380
  49.   j =  3                              :                0
  50.   j =  4                              :                0
  51.   j =  5                              :                0
  52.  
  53. -----------------------------------------------
  54. CPU time used                    :  00:03:58.25
  55.  
  56. Generator state:
  57.  
  58.  
  59.  
  60.  
  61. ***********************************************************
  62. Test smarsa_CollisionOver calling smultin_MultinomialOver
  63.  
  64. ***********************************************************
  65. HOST = xxxxxx, Linux
  66.  
  67. splitmix [High bits] [Byte Reversed]
  68.  
  69.  
  70. smultin_MultinomialOver test:
  71. -----------------------------------------------
  72.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1337
  93. p-value of test                       :    0.76
  94.  
  95. -----------------------------
  96. Total number of cells containing j balls
  97.  
  98.   j =  0                              :  131940795334457
  99.   j =  1                              :        599997326
  100.   j =  2                              :             1337
  101.   j =  3                              :                0
  102.   j =  4                              :                0
  103.   j =  5                              :                0
  104.  
  105. -----------------------------------------------
  106. CPU time used                    :  00:03:54.32
  107.  
  108. Generator state:
  109.  
  110.  
  111.  
  112.  
  113. ***********************************************************
  114. Test smarsa_CollisionOver calling smultin_MultinomialOver
  115.  
  116. ***********************************************************
  117. HOST = xxxxxx, Linux
  118.  
  119. splitmix [High bits] [Byte Reversed]
  120.  
  121.  
  122. smultin_MultinomialOver test:
  123. -----------------------------------------------
  124.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1335
  145. p-value of test                       :    0.78
  146.  
  147. -----------------------------
  148. Total number of cells containing j balls
  149.  
  150.   j =  0                              :  131940795334455
  151.   j =  1                              :        599997330
  152.   j =  2                              :             1335
  153.   j =  3                              :                0
  154.   j =  4                              :                0
  155.   j =  5                              :                0
  156.  
  157. -----------------------------------------------
  158. CPU time used                    :  00:04:03.57
  159.  
  160. Generator state:
  161.  
  162.  
  163.  
  164.  
  165. ***********************************************************
  166. Test smarsa_CollisionOver calling smultin_MultinomialOver
  167.  
  168. ***********************************************************
  169. HOST = xxxxxx, Linux
  170.  
  171. splitmix [High bits] [Byte Reversed]
  172.  
  173.  
  174. smultin_MultinomialOver test:
  175. -----------------------------------------------
  176.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1294
  197. p-value of test                       :    0.97
  198.  
  199. -----------------------------
  200. Total number of cells containing j balls
  201.  
  202.   j =  0                              :  131940795334414
  203.   j =  1                              :        599997412
  204.   j =  2                              :             1294
  205.   j =  3                              :                0
  206.   j =  4                              :                0
  207.   j =  5                              :                0
  208.  
  209. -----------------------------------------------
  210. CPU time used                    :  00:03:59.94
  211.  
  212. Generator state:
  213.  
  214.  
  215.  
  216.  
  217. ***********************************************************
  218. Test smarsa_CollisionOver calling smultin_MultinomialOver
  219.  
  220. ***********************************************************
  221. HOST = xxxxxx, Linux
  222.  
  223. splitmix [High bits] [Byte Reversed]
  224.  
  225.  
  226. smultin_MultinomialOver test:
  227. -----------------------------------------------
  228.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1351
  249. p-value of test                       :    0.63
  250.  
  251. -----------------------------
  252. Total number of cells containing j balls
  253.  
  254.   j =  0                              :  131940795334471
  255.   j =  1                              :        599997298
  256.   j =  2                              :             1351
  257.   j =  3                              :                0
  258.   j =  4                              :                0
  259.   j =  5                              :                0
  260.  
  261. -----------------------------------------------
  262. CPU time used                    :  00:03:56.63
  263.  
  264. Generator state:
  265.  
  266.  
  267.  
  268.  
  269. ***********************************************************
  270. Test smarsa_CollisionOver calling smultin_MultinomialOver
  271.  
  272. ***********************************************************
  273. HOST = xxxxxx, Linux
  274.  
  275. splitmix [High bits] [Byte Reversed]
  276.  
  277.  
  278. smultin_MultinomialOver test:
  279. -----------------------------------------------
  280.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1367
  301. p-value of test                       :    0.47
  302.  
  303. -----------------------------
  304. Total number of cells containing j balls
  305.  
  306.   j =  0                              :  131940795334487
  307.   j =  1                              :        599997266
  308.   j =  2                              :             1367
  309.   j =  3                              :                0
  310.   j =  4                              :                0
  311.   j =  5                              :                0
  312.  
  313. -----------------------------------------------
  314. CPU time used                    :  00:03:55.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. splitmix [High bits] [Byte Reversed]
  328.  
  329.  
  330. smultin_MultinomialOver test:
  331. -----------------------------------------------
  332.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1409
  353. p-value of test                       :    0.12
  354.  
  355. -----------------------------
  356. Total number of cells containing j balls
  357.  
  358.   j =  0                              :  131940795334529
  359.   j =  1                              :        599997182
  360.   j =  2                              :             1409
  361.   j =  3                              :                0
  362.   j =  4                              :                0
  363.   j =  5                              :                0
  364.  
  365. -----------------------------------------------
  366. CPU time used                    :  00:04:02.08
  367.  
  368. Generator state:
  369.  
  370.  
  371.  
  372.  
  373. ***********************************************************
  374. Test smarsa_CollisionOver calling smultin_MultinomialOver
  375.  
  376. ***********************************************************
  377. HOST = xxxxxx, Linux
  378.  
  379. splitmix [High bits] [Byte Reversed]
  380.  
  381.  
  382. smultin_MultinomialOver test:
  383. -----------------------------------------------
  384.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1453
  405. p-value of test                       :  8.9e-3
  406.  
  407. -----------------------------
  408. Total number of cells containing j balls
  409.  
  410.   j =  0                              :  131940795334573
  411.   j =  1                              :        599997094
  412.   j =  2                              :             1453
  413.   j =  3                              :                0
  414.   j =  4                              :                0
  415.   j =  5                              :                0
  416.  
  417. -----------------------------------------------
  418. CPU time used                    :  00:04:02.54
  419.  
  420. Generator state:
  421.  
  422.  
  423.  
  424.  
  425. ***********************************************************
  426. Test smarsa_CollisionOver calling smultin_MultinomialOver
  427.  
  428. ***********************************************************
  429. HOST = xxxxxx, Linux
  430.  
  431. splitmix [High bits] [Byte Reversed]
  432.  
  433.  
  434. smultin_MultinomialOver test:
  435. -----------------------------------------------
  436.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1399
  457. p-value of test                       :    0.18
  458.  
  459. -----------------------------
  460. Total number of cells containing j balls
  461.  
  462.   j =  0                              :  131940795334519
  463.   j =  1                              :        599997202
  464.   j =  2                              :             1399
  465.   j =  3                              :                0
  466.   j =  4                              :                0
  467.   j =  5                              :                0
  468.  
  469. -----------------------------------------------
  470. CPU time used                    :  00:04:02.90
  471.  
  472. Generator state:
  473.  
  474.  
  475.  
  476.  
  477. ***********************************************************
  478. Test smarsa_CollisionOver calling smultin_MultinomialOver
  479.  
  480. ***********************************************************
  481. HOST = xxxxxx, Linux
  482.  
  483. splitmix [High bits] [Byte Reversed]
  484.  
  485.  
  486. smultin_MultinomialOver test:
  487. -----------------------------------------------
  488.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1340
  509. p-value of test                       :    0.74
  510.  
  511. -----------------------------
  512. Total number of cells containing j balls
  513.  
  514.   j =  0                              :  131940795334460
  515.   j =  1                              :        599997320
  516.   j =  2                              :             1340
  517.   j =  3                              :                0
  518.   j =  4                              :                0
  519.   j =  5                              :                0
  520.  
  521. -----------------------------------------------
  522. CPU time used                    :  00:03:58.17
  523.  
  524. Generator state:
  525.  
  526.  
  527.  
  528.  
  529. ***********************************************************
  530. Test smarsa_CollisionOver calling smultin_MultinomialOver
  531.  
  532. ***********************************************************
  533. HOST = xxxxxx, Linux
  534.  
  535. splitmix [High bits] [Byte Reversed]
  536.  
  537.  
  538. smultin_MultinomialOver test:
  539. -----------------------------------------------
  540.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1329
  561. p-value of test                       :    0.83
  562.  
  563. -----------------------------
  564. Total number of cells containing j balls
  565.  
  566.   j =  0                              :  131940795334449
  567.   j =  1                              :        599997342
  568.   j =  2                              :             1329
  569.   j =  3                              :                0
  570.   j =  4                              :                0
  571.   j =  5                              :                0
  572.  
  573. -----------------------------------------------
  574. CPU time used                    :  00:03:56.38
  575.  
  576. Generator state:
  577.  
  578.  
  579.  
  580.  
  581. ***********************************************************
  582. Test smarsa_CollisionOver calling smultin_MultinomialOver
  583.  
  584. ***********************************************************
  585. HOST = xxxxxx, Linux
  586.  
  587. splitmix [High bits] [Byte Reversed]
  588.  
  589.  
  590. smultin_MultinomialOver test:
  591. -----------------------------------------------
  592.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1313
  613. p-value of test                       :    0.92
  614.  
  615. -----------------------------
  616. Total number of cells containing j balls
  617.  
  618.   j =  0                              :  131940795334433
  619.   j =  1                              :        599997374
  620.   j =  2                              :             1313
  621.   j =  3                              :                0
  622.   j =  4                              :                0
  623.   j =  5                              :                0
  624.  
  625. -----------------------------------------------
  626. CPU time used                    :  00:04:01.19
  627.  
  628. Generator state:
  629.  
  630.  
  631.  
  632.  
  633. ***********************************************************
  634. Test smarsa_CollisionOver calling smultin_MultinomialOver
  635.  
  636. ***********************************************************
  637. HOST = xxxxxx, Linux
  638.  
  639. splitmix [High bits] [Byte Reversed]
  640.  
  641.  
  642. smultin_MultinomialOver test:
  643. -----------------------------------------------
  644.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1288
  665. p-value of test                       :    0.98
  666.  
  667. -----------------------------
  668. Total number of cells containing j balls
  669.  
  670.   j =  0                              :  131940795334408
  671.   j =  1                              :        599997424
  672.   j =  2                              :             1288
  673.   j =  3                              :                0
  674.   j =  4                              :                0
  675.   j =  5                              :                0
  676.  
  677. -----------------------------------------------
  678. CPU time used                    :  00:04:00.88
  679.  
  680. Generator state:
  681.  
  682.  
  683.  
  684.  
  685. ***********************************************************
  686. Test smarsa_CollisionOver calling smultin_MultinomialOver
  687.  
  688. ***********************************************************
  689. HOST = xxxxxx, Linux
  690.  
  691. splitmix [High bits] [Byte Reversed]
  692.  
  693.  
  694. smultin_MultinomialOver test:
  695. -----------------------------------------------
  696.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1333
  717. p-value of test                       :    0.80
  718.  
  719. -----------------------------
  720. Total number of cells containing j balls
  721.  
  722.   j =  0                              :  131940795334453
  723.   j =  1                              :        599997334
  724.   j =  2                              :             1333
  725.   j =  3                              :                0
  726.   j =  4                              :                0
  727.   j =  5                              :                0
  728.  
  729. -----------------------------------------------
  730. CPU time used                    :  00:03:53.80
  731.  
  732. Generator state:
  733.  
  734.  
  735.  
  736.  
  737. ***********************************************************
  738. Test smarsa_CollisionOver calling smultin_MultinomialOver
  739.  
  740. ***********************************************************
  741. HOST = xxxxxx, Linux
  742.  
  743. splitmix [High bits] [Byte Reversed]
  744.  
  745.  
  746. smultin_MultinomialOver test:
  747. -----------------------------------------------
  748.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1368
  769. p-value of test                       :    0.46
  770.  
  771. -----------------------------
  772. Total number of cells containing j balls
  773.  
  774.   j =  0                              :  131940795334488
  775.   j =  1                              :        599997264
  776.   j =  2                              :             1368
  777.   j =  3                              :                0
  778.   j =  4                              :                0
  779.   j =  5                              :                0
  780.  
  781. -----------------------------------------------
  782. CPU time used                    :  00:03:53.13
  783.  
  784. Generator state:
  785.  
  786.  
  787.  
  788.  
  789. ***********************************************************
  790. Test smarsa_CollisionOver calling smultin_MultinomialOver
  791.  
  792. ***********************************************************
  793. HOST = xxxxxx, Linux
  794.  
  795. splitmix [High bits] [Byte Reversed]
  796.  
  797.  
  798. smultin_MultinomialOver test:
  799. -----------------------------------------------
  800.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1472
  821. p-value of test                       :  2.0e-3
  822.  
  823. -----------------------------
  824. Total number of cells containing j balls
  825.  
  826.   j =  0                              :  131940795334592
  827.   j =  1                              :        599997056
  828.   j =  2                              :             1472
  829.   j =  3                              :                0
  830.   j =  4                              :                0
  831.   j =  5                              :                0
  832.  
  833. -----------------------------------------------
  834. CPU time used                    :  00:03:55.44
  835.  
  836. Generator state:
  837.  
  838.  
  839.  
  840.  
  841. ***********************************************************
  842. Test smarsa_CollisionOver calling smultin_MultinomialOver
  843.  
  844. ***********************************************************
  845. HOST = xxxxxx, Linux
  846.  
  847. splitmix [High bits] [Byte Reversed]
  848.  
  849.  
  850. smultin_MultinomialOver test:
  851. -----------------------------------------------
  852.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1308
  873. p-value of test                       :    0.94
  874.  
  875. -----------------------------
  876. Total number of cells containing j balls
  877.  
  878.   j =  0                              :  131940795334428
  879.   j =  1                              :        599997384
  880.   j =  2                              :             1308
  881.   j =  3                              :                0
  882.   j =  4                              :                0
  883.   j =  5                              :                0
  884.  
  885. -----------------------------------------------
  886. CPU time used                    :  00:03:59.19
  887.  
  888. Generator state:
  889.  
  890.  
  891.  
  892.  
  893. ***********************************************************
  894. Test smarsa_CollisionOver calling smultin_MultinomialOver
  895.  
  896. ***********************************************************
  897. HOST = xxxxxx, Linux
  898.  
  899. splitmix [High bits] [Byte Reversed]
  900.  
  901.  
  902. smultin_MultinomialOver test:
  903. -----------------------------------------------
  904.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1407
  925. p-value of test                       :    0.13
  926.  
  927. -----------------------------
  928. Total number of cells containing j balls
  929.  
  930.   j =  0                              :  131940795334527
  931.   j =  1                              :        599997186
  932.   j =  2                              :             1407
  933.   j =  3                              :                0
  934.   j =  4                              :                0
  935.   j =  5                              :                0
  936.  
  937. -----------------------------------------------
  938. CPU time used                    :  00:03:59.26
  939.  
  940. Generator state:
  941.  
  942.  
  943.  
  944.  
  945. ***********************************************************
  946. Test smarsa_CollisionOver calling smultin_MultinomialOver
  947.  
  948. ***********************************************************
  949. HOST = xxxxxx, Linux
  950.  
  951. splitmix [High bits] [Byte Reversed]
  952.  
  953.  
  954. smultin_MultinomialOver test:
  955. -----------------------------------------------
  956.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1382
  977. p-value of test                       :    0.32
  978.  
  979. -----------------------------
  980. Total number of cells containing j balls
  981.  
  982.   j =  0                              :  131940795334502
  983.   j =  1                              :        599997236
  984.   j =  2                              :             1382
  985.   j =  3                              :                0
  986.   j =  4                              :                0
  987.   j =  5                              :                0
  988.  
  989. -----------------------------------------------
  990. CPU time used                    :  00:04:02.22
  991.  
  992. Generator state:
  993.  
  994.  
  995.  
  996.  
  997. ***********************************************************
  998. Test smarsa_CollisionOver calling smultin_MultinomialOver
  999.  
  1000. ***********************************************************
  1001. HOST = xxxxxx, Linux
  1002.  
  1003. splitmix [High bits] [Byte Reversed]
  1004.  
  1005.  
  1006. smultin_MultinomialOver test:
  1007. -----------------------------------------------
  1008.    N = 30,  n = 20000000,  r =  0,   d =    4,   t = 21,
  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         :     1336
  1029. p-value of test                       :    0.77
  1030.  
  1031. -----------------------------
  1032. Total number of cells containing j balls
  1033.  
  1034.   j =  0                              :  131940795334456
  1035.   j =  1                              :        599997328
  1036.   j =  2                              :             1336
  1037.   j =  3                              :                0
  1038.   j =  4                              :                0
  1039.   j =  5                              :                0
  1040.  
  1041. -----------------------------------------------
  1042. CPU time used                    :  00:03:54.71
  1043.  
  1044. Generator state:
  1045.  
  1046.  
  1047.  
  1048.  
  1049.  
  1050. ========= Summary results of BigCrush =========
  1051.  
  1052.  Version:          TestU01 1.2.3
  1053.  Generator:        splitmix [High bits] [Byte Reversed]
  1054.  Number of statistics:  20
  1055.  Total CPU time:   01:19:29.76
  1056.  
  1057.  All tests were passed
  1058.  
  1059.  
  1060.  
  1061.  - pvalues: 0.3384, 0.7648, 0.7812, 0.9713, 0.6334, 0.4738, 0.1158, 0.008918, 0.1766, 0.7389, 0.8264, 0.9159, 0.9806, 0.797, 0.463, 0.002042, 0.9351, 0.1265, 0.3189, 0.7731
  1062.  - pvalue stats: average 0.5571, stddev 0.1093
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