None

19-08-17 | pr | ps_sort_custom | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 46709 W: 8374 L: 8302 D: 30033 |
sprt @ 10+0.1 th 1 | balancing between 7+.07 and 10+.1. (700+time)<<depth. |

17-08-17 | pr | ps_sort_custom | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 39063 W: 7011 L: 6971 D: 25081 |
sprt @ 10+0.1 th 1 | stage 2: converging to ~(128<<((time>>7)+depth) |

17-08-17 | pr | ps_sort_custom | diff |
LLR: -2.94 (-2.94,2.94) [0.00,5.00] Total: 24656 W: 4430 L: 4450 D: 15776 |
sprt @ 10+0.1 th 1 | stage 2: dynamically calculate sort limit: 1024 - 15*depth*optimumTime |

16-08-17 | pr | ps_sort_zeros | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 16192 W: 2895 L: 2951 D: 10346 |
sprt @ 10+0.1 th 1 | 1024<<depth when depth < 5, otherwise sort all at 8-bit resolution. |

16-08-17 | pr | ps_sort_zeros | diff |
LLR: -1.38 (-2.94,2.94) [0.00,5.00] Total: 33280 W: 5849 L: 5769 D: 21662 |
sprt @ 10+0.1 th 1 | limit = 1024<<depth, for depth < 5. otherwise, sort everything roughly. |

15-08-17 | pr | ps_sort_optimize | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 9258 W: 1609 L: 1695 D: 5954 |
sprt @ 10+0.1 th 1 | testing convergence to +1k, -4K*depth. |

14-08-17 | pr | ps_sort_half | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 5250 W: 898 L: 1001 D: 3351 |
sprt @ 10+0.1 th 1 | optimizing number of moves per depth, instead of sort limit (depth). |

11-08-17 | pr | ps_sort_hybrid | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 16422 W: 2896 L: 2952 D: 10574 |
sprt @ 10+0.1 th 1 | simplified sorting when depth > 5 (at that depth we usually sort everything anyways). |

10-08-17 | pr | ps_optimize | diff |
LLR: -2.02 (-2.94,2.94) [0.00,5.00] Total: 15882 W: 2863 L: 2881 D: 10138 |
sprt @ 10+0.1 th 1 | Slight improvement locally. VERY IMPORTANT: 10+0.1 games only. |

09-08-17 | pr | ps_optimize | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 7304 W: 1283 L: 1377 D: 4644 |
sprt @ 10+0.1 th 1 | test value convergence for 10+.1 games. |

09-08-17 | pr | ps_sort_custom | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 6840 W: 1202 L: 1298 D: 4340 |
sprt @ 10+0.1 th 1 | stage 1: optimizing sort limits for 10+0.1 games. |

07-08-17 | pr | ps_limits | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 2590 W: 422 L: 537 D: 1631 |
sprt @ 10+0.1 th 1 | shift sort limit calculations down to depth 3+. |

07-08-17 | pr | ps_sort_half | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 4061 W: 685 L: 793 D: 2583 |
sprt @ 10+0.1 th 1 | instead of limits, always sort 1/2 of moves. |

05-08-17 | pr | ps_sort_hybrid | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 10714 W: 1867 L: 1947 D: 6900 |
sprt @ 10+0.1 th 1 | hybrid sorting at 8 bit resolution. |

05-08-17 | pr | ps_sort_swap | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 10177 W: 1731 L: 1813 D: 6633 |
sprt @ 10+0.1 th 1 | hybrid sorting rules. Kills master at 40/5 games. |

05-08-17 | pr | ps_sort_bits | diff |
LLR: -2.97 (-2.94,2.94) [0.00,5.00] Total: 1310 W: 170 L: 289 D: 851 |
sprt @ 10+0.1 th 1 | Only sort to the 1000's place. |

04-08-17 | pr | ps_sort_inv | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 2628 W: 435 L: 550 D: 1643 |
sprt @ 10+0.1 th 1 | home tourney winner. more narrow searching with increased depth. |

03-08-17 | pr | ps_rev_sort | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 5779 W: 933 L: 1033 D: 3813 |
sprt @ 10+0.1 th 1 | reverse order of moves before sorting. Better on my machine, don't know why. |

03-08-17 | pr | ps_sort_whileGenerating | diff |
LLR: -2.94 (-2.94,2.94) [0.00,5.00] Total: 4841 W: 805 L: 909 D: 3127 |
sprt @ 10+0.1 th 1 | sort moves while generating (full sort of all moves). No limits. No partial sorting. |

02-08-17 | pr | ps_sort_stable2 | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 1970 W: 318 L: 436 D: 1216 |
sprt @ 10+0.1 th 1 | keep unsorted moves in order + lower sort limit. (increase tt hits?) |

01-08-17 | pr | ps_sort_nocpy | diff |
LLR: 0.05 (-2.94,2.94) [0.00,5.00] Total: 42809 W: 7804 L: 7620 D: 27385 |
sprt @ 10+0.1 th 1 | NON-FUNCTIONAL: don't copy moves if we don't need to. |

01-08-17 | pr | ps_sort_scale | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 6887 W: 1207 L: 1303 D: 4377 |
sprt @ 10+0.1 th 1 | scale move sorting limit exponentially instead of linearly. |

01-08-17 | pr | ps_sort_test | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 12782 W: 2216 L: 2287 D: 8279 |
sprt @ 10+0.1 th 1 | presort moves, then simplify assuming all sequential moves are over limit, and quit after hitting moves under limit. |

31-07-17 | pr | ps_dual_sort2 | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 3985 W: 630 L: 738 D: 2617 |
sprt @ 10+0.1 th 1 | Low resolution dual insertion sort (no limits). |

31-07-17 | pr | ps_dual_sort | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 5776 W: 981 L: 1082 D: 3713 |
sprt @ 10+0.1 th 1 | sort positives using MSB, sort negatives in groups. |

31-07-17 | pr | ps_dual_sort | diff |
LLR: -1.50 (-2.94,2.94) [0.00,5.00] Total: 3666 W: 613 L: 661 D: 2392 |
sprt @ 10+0.1 th 1 | Help the sorting a bit. This is a bit faster on my machine. |

30-07-17 | pr | ps_bit_sort | diff |
ELO: -3.18 +-3.5 (95%) LOS: 3.8% Total: 13232 W: 2255 L: 2376 D: 8601 |
20000 @ 10+0.1 th 1 | try to help the sorting a bit. |

30-07-17 | pr | ps_bit_sort | diff |
ELO: -14.86 +-4.6 (95%) LOS: 0.0% Total: 7837 W: 1260 L: 1595 D: 4982 |
20000 @ 10+0.1 th 1 | closer to original. . (mostly for my information). |

30-07-17 | pr | ps_bit_sort | diff |
ELO: -1.23 +-2.9 (95%) LOS: 20.1% Total: 20000 W: 3539 L: 3610 D: 12851 |
20000 @ 10+0.1 th 1 | sort positive when depth < 3, sort all when depth > 3. |

29-07-17 | pr | ps_bit_sort | diff |
ELO: -7.45 +-5.8 (95%) LOS: 0.6% Total: 4945 W: 824 L: 930 D: 3191 |
5000 @ 10+0.1 th 1 | test only: last test of bit sort. |

28-07-17 | pr | ps_group_sort | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 2950 W: 483 L: 596 D: 1871 |
sprt @ 10+0.1 th 1 | test only: sort more instead of less (less seems to always be worse). |

28-07-17 | pr | ps_group_sort | diff |
LLR: -2.97 (-2.94,2.94) [0.00,5.00] Total: 3429 W: 558 L: 669 D: 2202 |
sprt @ 10+0.1 th 1 | test only: faster rough sorting of all moves instead of sorting moves over an arbitrary limit. |

28-07-17 | pr | ps_bit_sort | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 3099 W: 506 L: 618 D: 1975 |
sprt @ 10+0.1 th 1 | Test Only. Instead of sorting moves above arbitrary limit, sort all, but roughly. |

27-07-17 | pr | ps_rough_sort8 | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 36452 W: 6504 L: 6475 D: 23473 |
sprt @ 10+0.1 th 1 | try3: sort using MSB's (ignore lower 8 bits). |

27-07-17 | pr | ps_rough_sort | diff |
LLR: -0.53 (-2.94,2.94) [0.00,5.00] Total: 167 W: 15 L: 36 D: 116 |
sprt @ 10+0.1 th 1 | sort only on MSB's. |

27-07-17 | pr | ps_sort4 | diff |
LLR: -2.96 (-2.94,2.94) [0.00,5.00] Total: 4748 W: 793 L: 898 D: 3057 |
sprt @ 10+0.1 th 1 | simplification. instead of partial_insertion_sort over some arbitrary limit, sort top depth*4 moves. |

26-07-17 | pr | ps_sort3 | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 9888 W: 1711 L: 1794 D: 6383 |
sprt @ 10+0.1 th 1 | limit partial_insertion_sort (don't sort so many). Should this -4000 be a tunable value? |

22-07-17 | pr | ps_sort2 | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 15325 W: 2735 L: 2795 D: 9795 |
sprt @ 10+0.1 th 1 | different move sort. Bench is different but can't figure out why. Should be faster. May I test? |

21-07-17 | pr | ps_sort | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 21122 W: 3791 L: 3826 D: 13505 |
sprt @ 10+0.1 th 1 | Simplifies unnecessary sorting resulting in a very modest speed increase. |

04-07-17 | pr | ps_partial_sorting | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 602 W: 62 L: 185 D: 355 |
sprt @ 10+0.1 th 1 | faster (in most situations) partial insertion sorting. |

26-06-17 | pr | ps_search_branch | diff |
LLR: -2.95 (-2.94,2.94) [0.00,5.00] Total: 23076 W: 4144 L: 4171 D: 14761 |
sprt @ 10+0.1 th 1 | custom sort for moves list (instead of sorting whole array). |