Merge pull request #23 from boraaros/guess-strategy

iterative search guess strategy

Author: boraaros

Alligator.Benchmark/Program.cs

@@ -74,6 +74,7 @@ private static IEnumerable<IPosition> EnumerateExamples()
             yield return Example3();
             yield return Example4();
             yield return Example5();
+            yield return Example6();
         }
 
         #region Examles
@@ -158,6 +159,30 @@ private static IPosition Example5()
             return position;
         }
 
+        private static IPosition Example6()
+        {
+            IPosition position = new Position();
+            position.Take(new Placement(0));
+            position.Take(new Placement(12));
+            position.Take(new Placement(1));
+            position.Take(new Placement(7));
+            position.Take(new Placement(2));
+            position.Take(new Placement(13));
+            position.Take(new Placement(11));
+            position.Take(new Placement(17));
+            position.Take(new Movement(2, 7, 1));
+            position.Take(new Placement(8));
+            position.Take(new Placement(16));
+            position.Take(new Placement(22));
+            position.Take(new Movement(7, 12, 2));
+            position.Take(new Movement(12, 1, 1));
+            position.Take(new Movement(11, 12, 1));
+            position.Take(new Movement(12, 1, 1));
+            position.Take(new Movement(1, 8, 3));
+            position.Take(new Movement(13, 8, 1));
+            return position;
+        }
+
         #endregion
     }
 }

Alligator.Solver/Algorithms/AlphaBetaSolver.cs

@@ -10,6 +10,8 @@ internal class AlphaBetaSolver<TPosition, TStep> : ISolver<TStep>
         private readonly ISearchManager searchManager;
         private readonly Action<string> logger;
 
+        private const int maxDepth = 7; // TODO: magic number!
+
         public AlphaBetaSolver(
             AlphaBetaPruning<TPosition, TStep> alphaBetaPruning,
             IRules<TPosition, TStep> rules,
@@ -31,7 +33,7 @@ public TStep OptimizeNextStep(IList<TStep> history)
             var bestStep = default(TStep);
             var guess = 0;
 
-            for (int i = 2; i < 7; i += 2) // TODO: magic number (7)!
+            for (int i = 2; i < maxDepth; i += 2) 
             {
                 searchManager.DepthLimit = i;
                 var (OptimalSteps, Value) = BestNodeSearch(position, guess);
@@ -45,17 +47,25 @@ public TStep OptimizeNextStep(IList<TStep> history)
 
         private (ICollection<TStep> OptimalSteps, int Value) BestNodeSearch(TPosition position, int guess)
         {
-            int alpha = -int.MaxValue;
-            int beta = int.MaxValue;
+            int alpha = -sbyte.MaxValue - maxDepth;
+            int beta = sbyte.MaxValue + maxDepth;
 
             IList<TStep> candidates = rules.LegalStepsAt(position).ToList();
 
+            var optimalValue = 0;
+
             while (alpha + 1 < beta && candidates.Count > 1)
             {
                 var newCandidates = new List<TStep>();
 
                 foreach (var move in candidates)
                 {
+                    if (newCandidates.Count > 1)
+                    {
+                        newCandidates.Add(move);
+                        continue;
+                    }
+
                     int value = NullWindowTest(position, move, guess);
 
                     if (value >= guess)
@@ -66,6 +76,7 @@ public TStep OptimizeNextStep(IList<TStep> history)
 
                 if (newCandidates.Count > 0)
                 {
+                    optimalValue = guess;
                     candidates = newCandidates;
                     alpha = guess;
                 }
@@ -74,10 +85,10 @@ public TStep OptimizeNextStep(IList<TStep> history)
                     beta = guess;
                 }
 
-                guess = NextGuess(alpha, beta, candidates.Count);
+                guess = newCandidates.Count > 0 ? guess + 1 : guess - 1;
             }
 
-            return (candidates, guess);
+            return (candidates, optimalValue);
         }
 
         private int NullWindowTest(TPosition position, TStep step, int guess)
@@ -88,31 +99,6 @@ private int NullWindowTest(TPosition position, TStep step, int guess)
             return value;
         }
 
-        private int NextGuess(int alpha, int beta, int count)
-        {
-            if (alpha <= 0)
-            {
-                beta = Math.Min(beta, int.MaxValue / 2);
-            }
-
-            if (beta >= 0)
-            {
-                alpha = Math.Max(alpha, -int.MaxValue / 2);
-            }
-
-            var guess = (int)(alpha + (count - 1.0) / count * (beta - alpha));
-
-            if (guess == alpha)
-            {
-                return guess + 1;
-            }
-            else if (guess == beta)
-            {
-                return guess - 1;
-            }
-            return guess;
-        }
-
         private TPosition CreatePosition(IEnumerable<TStep> history)
         {
             var position = rules.InitialPosition();

Alligator.Solver/Algorithms/CacheTables.cs

@@ -8,8 +8,8 @@ internal class CacheTables<TPosition, TStep> : ICacheTables<TPosition, TStep>
 
         public CacheTables()
         {
-            evaluationTable = new Dictionary<ulong, int>();
-            transpositionTable = new Dictionary<ulong, Transposition<TStep>>();
+            evaluationTable = new Dictionary<ulong, int>(10000000);
+            transpositionTable = new Dictionary<ulong, Transposition<TStep>>(10000000);
         }
 
         public void AddTransposition(TPosition position, Transposition<TStep> transposition)