Fix Makefile for HPUX

[stockfish] / src / move.h

diff --git a/src/move.h b/src/move.h
index 4e86a68908f6e2a68bb31254935426e3e3e4327f..765328713a7201d4a49770752b5fe86b805d8693 100644 (file)
--- a/src/move.h
+++ b/src/move.h
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2009 Marco Costalba
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -65,15 +65,15 @@ struct MoveStack {
 // Note that operator< is set up such that sorting will be in descending order
 inline bool operator<(const MoveStack& f, const MoveStack& s) { return s.score < f.score; }
 
-// Our stable insertion sort in range [firstMove, lastMove), platform independent
+// An helper insertion sort implementation
 template<typename T>
-inline void sort_moves(T* firstMove, T* lastMove)
+inline void insertion_sort(T* firstMove, T* lastMove)
 {
     T value;
     T *cur, *p, *d;
 
     if (firstMove != lastMove)
-        for (cur = firstMove; ++cur != lastMove; )
+        for (cur = firstMove + 1; cur != lastMove; cur++)
         {
             p = d = cur;
             value = *p--;
@@ -86,6 +86,39 @@ inline void sort_moves(T* firstMove, T* lastMove)
         }
 }
 
+// Our dedicated sort in range [firstMove, lastMove), first splits
+// positive scores from ramining then order seaprately the two sets.
+template<typename T>
+inline void sort_moves(T* firstMove, T* lastMove, T** lastPositive)
+{
+    T tmp;
+    T *p, *d;
+
+    d = lastMove;
+    p = firstMove - 1;
+
+    d->score = -1; // right guard
+
+    // Split positives vs non-positives
+    do {
+        while ((++p)->score > 0) {}
+
+        if (p != d)
+        {
+            while (--d != p && d->score <= 0) {}
+
+            tmp = *p;
+            *p = *d;
+            *d = tmp;
+        }
+
+    } while (p != d);
+
+    // Sort just positive scored moves, remaining only when we get there
+    insertion_sort<T>(firstMove, p);
+    *lastPositive = p;
+}
+
 // Picks up the best move in range [curMove, lastMove), one per cycle.
 // It is faster then sorting all the moves in advance when moves are few,
 // as normally are the possible captures. Note that is not a stable alghoritm.