X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Ftypes.h;h=f921f9e105cb66cd503d81b87635e538e30dda93;hp=eea7d26460e6ac7b88101713ae97081129d13337;hb=880e3cd7c82c82776e85042c849e884811378e21;hpb=da2f8880b96004505e27b0b87f5df5bfe67a72a9

diff --git a/src/types.h b/src/types.h
index eea7d264..f921f9e1 100644
--- a/src/types.h
+++ b/src/types.h
@@ -55,7 +55,7 @@
 #endif
 
 #if defined(USE_PEXT)
-#  include <x86intrin.h> // Gcc header for _pext_u64() intrinsic
+#  include <immintrin.h> // Header for _pext_u64() intrinsic
 #else
 #  define _pext_u64(b, m) (0)
 #endif
@@ -136,7 +136,7 @@ enum CastlingSide {
   KING_SIDE, QUEEN_SIDE, CASTLING_SIDE_NB = 2
 };
 
-enum CastlingRight {  // Defined as in PolyGlot book hash key
+enum CastlingRight {
   NO_CASTLING,
   WHITE_OO,
   WHITE_OOO   = WHITE_OO << 1,
@@ -191,7 +191,9 @@ enum Value {
   KnightValueMg = 817,   KnightValueEg = 846,
   BishopValueMg = 836,   BishopValueEg = 857,
   RookValueMg   = 1270,  RookValueEg   = 1278,
-  QueenValueMg  = 2521,  QueenValueEg  = 2558
+  QueenValueMg  = 2521,  QueenValueEg  = 2558,
+
+  MidgameLimit  = 15581, EndgameLimit  = 3998
 };
 
 enum PieceType {
@@ -216,7 +218,7 @@ enum Depth {
   DEPTH_QS_NO_CHECKS  = -1 * ONE_PLY,
   DEPTH_QS_RECAPTURES = -5 * ONE_PLY,
 
-  DEPTH_NONE = -127 * ONE_PLY
+  DEPTH_NONE = -6 * ONE_PLY
 };
 
 enum Square {
@@ -270,24 +272,15 @@ inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
 /// Extracting the signed lower and upper 16 bits is not so trivial because
 /// according to the standard a simple cast to short is implementation defined
 /// and so is a right shift of a signed integer.
-inline Value mg_value(Score s) { return Value(((s + 0x8000) & ~0xffff) / 0x10000); }
-
-/// On Intel 64 bit we have a small speed regression with the standard conforming
-/// version. Therefore, in this case we use faster code that, although not 100%
-/// standard compliant, seems to work for Intel and MSVC.
-#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER))
-
-inline Value eg_value(Score s) { return Value(int16_t(s & 0xFFFF)); }
-
-#else
+inline Value mg_value(Score s) {
+  return Value(((s + 0x8000) & ~0xffff) / 0x10000);
+}
 
 inline Value eg_value(Score s) {
   return Value((int)(unsigned(s) & 0x7FFFU) - (int)(unsigned(s) & 0x8000U));
 }
 
-#endif
-
-#define ENABLE_SAFE_OPERATORS_ON(T)                                         \
+#define ENABLE_BASE_OPERATORS_ON(T)                                         \
 inline T operator+(const T d1, const T d2) { return T(int(d1) + int(d2)); } \
 inline T operator-(const T d1, const T d2) { return T(int(d1) - int(d2)); } \
 inline T operator*(int i, const T d) { return T(i * int(d)); }              \
@@ -297,26 +290,32 @@ inline T& operator+=(T& d1, const T d2) { return d1 = d1 + d2; }            \
 inline T& operator-=(T& d1, const T d2) { return d1 = d1 - d2; }            \
 inline T& operator*=(T& d, int i) { return d = T(int(d) * i); }
 
-#define ENABLE_OPERATORS_ON(T) ENABLE_SAFE_OPERATORS_ON(T)                  \
+ENABLE_BASE_OPERATORS_ON(Score)
+
+#define ENABLE_FULL_OPERATORS_ON(T)                                         \
+ENABLE_BASE_OPERATORS_ON(T)                                                 \
 inline T& operator++(T& d) { return d = T(int(d) + 1); }                    \
 inline T& operator--(T& d) { return d = T(int(d) - 1); }                    \
 inline T operator/(const T d, int i) { return T(int(d) / i); }              \
 inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
 
-ENABLE_OPERATORS_ON(Value)
-ENABLE_OPERATORS_ON(PieceType)
-ENABLE_OPERATORS_ON(Piece)
-ENABLE_OPERATORS_ON(Color)
-ENABLE_OPERATORS_ON(Depth)
-ENABLE_OPERATORS_ON(Square)
-ENABLE_OPERATORS_ON(File)
-ENABLE_OPERATORS_ON(Rank)
+ENABLE_FULL_OPERATORS_ON(Value)
+ENABLE_FULL_OPERATORS_ON(PieceType)
+ENABLE_FULL_OPERATORS_ON(Piece)
+ENABLE_FULL_OPERATORS_ON(Color)
+ENABLE_FULL_OPERATORS_ON(Depth)
+ENABLE_FULL_OPERATORS_ON(Square)
+ENABLE_FULL_OPERATORS_ON(File)
+ENABLE_FULL_OPERATORS_ON(Rank)
+
+#undef ENABLE_FULL_OPERATORS_ON
+#undef ENABLE_BASE_OPERATORS_ON
 
 /// Additional operators to add integers to a Value
 inline Value operator+(Value v, int i) { return Value(int(v) + i); }
 inline Value operator-(Value v, int i) { return Value(int(v) - i); }
-
-ENABLE_SAFE_OPERATORS_ON(Score)
+inline Value& operator+=(Value& v, int i) { return v = v + i; }
+inline Value& operator-=(Value& v, int i) { return v = v - i; }
 
 /// Only declared but not defined. We don't want to multiply two scores due to
 /// a very high risk of overflow. So user should explicitly convert to integer.
@@ -327,8 +326,7 @@ inline Score operator/(Score s, int i) {
   return make_score(mg_value(s) / i, eg_value(s) / i);
 }
 
-#undef ENABLE_OPERATORS_ON
-#undef ENABLE_SAFE_OPERATORS_ON
+CACHE_LINE_ALIGNMENT
 
 extern Value PieceValue[PHASE_NB][PIECE_NB];
 
@@ -407,14 +405,6 @@ inline bool opposite_colors(Square s1, Square s2) {
   return ((s >> 3) ^ s) & 1;
 }
 
-inline char to_char(File f, bool tolower = true) {
-  return char(f - FILE_A + (tolower ? 'a' : 'A'));
-}
-
-inline char to_char(Rank r) {
-  return char(r - RANK_1 + '1');
-}
-
 inline Square pawn_push(Color c) {
   return c == WHITE ? DELTA_N : DELTA_S;
 }
@@ -448,11 +438,4 @@ inline bool is_ok(Move m) {
   return from_sq(m) != to_sq(m); // Catches also MOVE_NULL and MOVE_NONE
 }
 
-#include <string>
-
-inline const std::string to_string(Square s) {
-  char ch[] = { to_char(file_of(s)), to_char(rank_of(s)), 0 };
-  return ch;
-}
-
 #endif // #ifndef TYPES_H_INCLUDED