Monday, September 24, 2012

Perft for Checkers for Depth 28

My quest for deeper perft numbers for 8x8 checkers using has reached depth 28. Below you see the perft(28) breakdown per move, called "divide". As stated before, the numbers were computed on a cluster of machines, optimized with a "hard collision"-free transposition table as well as bulk counting. The move generator does not eliminate duplicate captures.

At this point, the limits of 64-bit unsigned integers have been reached. Although there are obvious ways around these restrictions, this seems a very good time to give this (by now probably insane) project a rest. I have updated this OEIS entry up to depth 26, and may add the higher depths also when I am a bit more comfortable with these most recent results.

divide(28)
12-16 = 2400708339858199191
11-16 = 2431386196712611878
11-15 = 2231787529331259810
10-15 = 2186446356811761737
10-14 = 1872427919495823777
 9-14 = 2285893686261887442
 9-13 = 2969067990365356900
 --------------------------
perft(28) = 16377718018836900735




Thursday, September 20, 2012

Perft for Checkers for Depth 27

With the new improvements in place, it would almost be a waste not to go deeper with my perft for checkers computation. Therefore, I computed perft(27) from the initial position of 8x8 checkers. Below you see the perft breakdown per move, called "divide". As stated before, these numbers were computed on a cluster of machines, further optimized with a "hard collision"-free transposition table as well as bulk counting. The move generator does not eliminate duplicate captures.

 move                 divide(27)
-------------------------------
 12-16    =  516399283859880203
 11-16    =  519502096014967805
 11-15    =  476666239516455180
 10-15    =  468705060101275533
 10-14    =  400425747281243848
  9-14    =  486493422418651579
   9-13    =  631652334435528457 
-------------------------------
perft(27) = 3499844183628002605

The implementation is "fault tolerant" against machine failures. Nevertheless, since I saw a few of these recoveries in this particular run, I may rerun this depth soon to verify the results pedantically.

Tuesday, September 18, 2012

Perft for Checkers for Depth 26

I made some improvements to my distributed implementation for computing perft and divide numbers for 8x8 checkers, and now computed depth 26 from the initial position, shown below. As reported earlier, the numbers were computed on a cluster of machines, further optimized with a "hard collision"-free transposition table as well as bulk counting. The move generator does not eliminate duplicate captures (viz. the situation where a king can capture the same pieces in different directions; a situation that starts to occur at depth 12 and up).

move              divide(26)
----------------------------
12-16:    111362678435231752
11-16:    112590257768420515
11-15:    101352649993886926
10-15:    100552646996749293
10-14:     86312674861234785
 9-14:    103811787278058952
 9-13:    136189763354484914
----------------------------
perft(26) 752172458688067137
 
 

Wednesday, September 12, 2012

Perft for Checkers for Depth 25

Continuing my quest for deeper and deeper perft numbers for 8x8 checkers, I now computed depth 25 with the same distributed implementation I used earlier for depths up to 24. Below you see the perft breakdown per move (called "divide") from the initial position for depths 23, 24 and 25 (my depth 23 and 24 numbers were recently kindly confirmed by Murray Cash at the World Draughts Forum).

move          divide(23)        divide(24)          divide(25)
--------------------------------------------------------------
12-16:  1123463594881857  5192042148594780   24019313789608561
11-16:  1131373985922218  5248615918291379   24153215782987793
11-15:   984253557821317  4602138522979438   21659601983574539
10-15:  1000606302770349  4643700995955222   21609957136212495
10-14:   856779998157523  3988937724259353   18496978526984076
 9-14:  1003310451936358  4712325943133747   22101040287502927
 9-13:  1337748969176591  6263620622082081   29027372375205409
--------------------------------------------------------------
        7437536860666213 34651381875296000  161067479882075800


The numbers were computed on on a cluster of machines, further optimized with a "hard collision"-free transposition table as well as bulk counting. Please note that the move generator does not eliminate duplicate captures (viz. the situation where a king can capture the same pieces in different directions; a situation that starts to occur at depth 12 and up).

Wednesday, September 5, 2012

Further Localication

I just released version 4.0.5 of Chess for Android, available through Google Play or as direct download. This release mainly extends localization to more languages, but it also provides a new feature: copying the engine analysis to the clipboard. The following languages are now supported:
  • Afrikaans (af)
  • Chinese (zh)
  • Czech (cs)
  • Dutch (nl)
  • English (en)
  • French (fr)
  • German (de)
  • Hebrew (iw)
  • Hindi (hi)        [coming soon]
  • Icelandic (is)   [coming soon]
  • Italian (it)
  • Polish (pl)
  • Portuguese (pt-br)
  • Russian (ru)
  • Spanish (es)
  • Swedish (sv)
  • Turkish (tr)
Many thanks to my translation team: Vinícius Angiolucci, Lucas Braesch, A.N. Bürümcekci, Panna Chowdhury, Anton Hansson, Arnar Mar Hrafnkelsson, Michal Kaczmarek, Dara Koper, Morgan Lombard, Krizia Lopez, Dennis Prochko, Martin Sedlák, Philip Stutz, Haran Talmon, Ted Wong, and last but certainly not least C.R. Zamana!