Stockfish DD – types.h | やねうら王公式サイト

今回はStockfishのtypes.hの解説です。このファイルはBonanza6で言うとshogi.hに相当するもので、チェスで使う基本的な構造体の定義が一式書かれています。このファイルの内容を頭においてからソースコードを読み進めれば細部まで理解しやすいでしょう。

/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2013 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
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Stockfish is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef TYPES_H_INCLUDED
#define TYPES_H_INCLUDED

/// For Linux and OSX configuration is done automatically using Makefile. To get
/// started type 'make help'.
///
/// For Windows, part of the configuration is detected automatically, but some
/// switches need to be set manually:
///
/// -DNDEBUG      | Disable debugging mode. Use always.
///
/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. A must if you want
///               | the executable to run on some very old machines.
///
/// -DUSE_POPCNT  | Add runtime support for use of popcnt asm-instruction. Works
///               | only in 64-bit mode. For compiling requires hardware with
///               | popcnt support.

// LinuxとOSXの設定は、Makefileによって自動的に行われる。'make help'から始めよ。
//
// Windowsでは、設定の一部は自動的に検知されるが、いくつかのスイッチは手動でセットする必要がある。
//
// -DNDEBUG      | デバッグモードを無効にする。いつでも使える。
//
// -DNO_PREFETCH | asm命令であるprefetchを使うのを無効化する。
//                もし非常に古いマシンで走らせたいなら必要である。
//
// -DUSE_POPCNT  | asm命令であるpopcnt(SSE4.2から対応)の使用に関してランタイムのサポートを追加する。
//                これは64bitモードでのみ動作する。
//                このコンパイル(した実行ファイル)はpopcntをサポートしているハードウェアを必要とする。

#include <cassert>
#include <cctype>
#include <climits>
#include <cstdint>
#include <cstdlib>

#if defined(_MSC_VER)
// Disable some silly and noisy warning from MSVC compiler
#pragma warning(disable: 4127) // Conditional expression is constant
#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
#endif

#define unlikely(x) (x) // For code annotation purposes

#if defined(_WIN64) && !defined(IS_64BIT)
#  include <intrin.h> // MSVC popcnt and bsfq instrinsics
#  define IS_64BIT
#  define USE_BSFQ
#endif

#if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)
#  include <nmmintrin.h> // Intel header for _mm_popcnt_u64() intrinsic
#endif

#  if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))
#   include <xmmintrin.h> // Intel and Microsoft header for _mm_prefetch()
#  endif

// メモリのキャッシュラインのサイズ
// (1バイト目を読み込むと、後続の64バイトが読み込まれる。)
#define CACHE_LINE_SIZE 64
#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
#  define CACHE_LINE_ALIGNMENT __declspec(align(CACHE_LINE_SIZE))
#else
#  define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(CACHE_LINE_SIZE)))
#endif

// MSVCなのか
#ifdef _MSC_VER
#  define FORCE_INLINE  __forceinline
#elif defined(__GNUC__)
#  define FORCE_INLINE  inline __attribute__((always_inline))
#else
#  define FORCE_INLINE  inline
#endif

// POPCNTを用いるのか。SSE4.2以降。
#ifdef USE_POPCNT
const bool HasPopCnt = true;
#else
const bool HasPopCnt = false;
#endif

// 64bitモード用にコンパイルするのか。
#ifdef IS_64BIT
const bool Is64Bit = true;
#else
const bool Is64Bit = false;
#endif

// 局面のハッシュキー
typedef uint64_t Key;

// 盤面を表すbitboard。チェスは64升なので64bit変数にぴったり収まる。
typedef uint64_t Bitboard;


// ある局面の最大の指し手数
const int MAX_MOVES = 256;

// 探索最大深さ
const int MAX_PLY = 100;

// 探索最大深さ+6 (バッファを余分に確保する用)
const int MAX_PLY_PLUS_6 = MAX_PLY + 6;


/// A move needs 16 bits to be stored
///
/// bit  0- 5: destination square (from 0 to 63)
/// bit  6-11: origin square (from 0 to 63)
/// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2)
/// bit 14-15: special move flag: promotion (1), en passant (2), castle (3)
///
/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in because in
/// any normal move destination square is always different from origin square
/// while MOVE_NONE and MOVE_NULL have the same origin and destination square.
/*
指し手は格納するのに16-bit必要である。
bit 0-5  : 移動先(0から63までの値)
bit 6-11 : 移動元(0から63までの値)
bit 12-13: promotion piece type(成駒の駒種の値)から2を引いた値(KNIGHT-2からQUEEN-2)
bit 14-15: 特殊な移動フラグ : 成り(1) , アンパッサン(2) , キャスリング(3)

特殊な移動値として、MOVE_NONEとMOVE_NULLがある。
普通の指し手は、移動元と移動先とは異なるはずである。(移動していない指し手はないので)
そこで、移動元=0かつ移動先=0だとか、移動元=1かつ移動先=1のような指し手は通常は出現しないので
これを特殊な用途に使うことが出来る。
*/
enum Move {
  // 無効な値であることを示す特殊な値。移動元=0,移動先=0
  MOVE_NONE,

  // null move枝刈りのときに使う特殊な移動の値。移動元=1,移動先=1 ( 1*64 + 1 == 65)
  MOVE_NULL = 65

  // MOVE_NONE,MOVE_NULLを捕捉するのに
  //  return from_sq(m) != to_sq(m)
  // のように書けるのが唯一の利点なのだが、将棋で、例えば駒打ちをfrom = 駒種にしてしまうと
  // そうは書けなくなる。まあ、仕方がないか…。
  // is_ok(Move)でしかそんな判定していないしな…。

};

// 移動の種類(Moveのbit14,15のための定数)
enum MoveType {
  NORMAL, // 通常移動
  PROMOTION = 1 << 14, // 成り
  ENPASSANT = 2 << 14, // アンパッサン
  CASTLE = 3 << 14  // キャスリング
};


enum CastleRight {  // Defined as in PolyGlot book hash key
  CASTLES_NONE,
  WHITE_OO,
  WHITE_OOO = WHITE_OO << 1,
  BLACK_OO = WHITE_OO << 2,
  BLACK_OOO = WHITE_OO << 3,
  ALL_CASTLES = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,
  CASTLE_RIGHT_NB = 16
};

enum CastlingSide {
  KING_SIDE,
  QUEEN_SIDE,
  CASTLING_SIDE_NB = 2
};

enum Phase {
  PHASE_ENDGAME,
  PHASE_MIDGAME = 128,
  MG = 0, EG = 1, PHASE_NB = 2
};

enum ScaleFactor {
  SCALE_FACTOR_DRAW = 0,
  SCALE_FACTOR_NORMAL = 64,
  SCALE_FACTOR_MAX = 128,
  SCALE_FACTOR_NONE = 255
};

// スコア(評価値)がどういう探索の結果得た値なのかを表現する。
enum Bound {
  // 探索しておらず、局面の静的評価値か最善手のみを置換表に突っ込みたいときに用いる。
  BOUND_NONE,

  // fail-lowしたときの状態。この局面のスコアの最大値であり、このnodeの真の評価値はttValue以下である。
  // non PV nodeとか、bestMoveがない(適当な見積もりで枝刈りした場合など)は、この状態
  BOUND_UPPER,

  // fail-highしたときの状態。この局面のスコアの最低保証値であり、このnodeの真の評価値はttValue以上である。
  // beta cutしたときに、そのときの値を置換表に格納するときに使う。
  // beta cutなので他の残りの指し手に関して、これよりいい評価値のものがあるはずだという意味で使う。
  BOUND_LOWER,

  // fail-lowもfail-highもしておらず正確なスコアと言える状態
  // 	PvNodeでかつbestMoveが具体的な指し手として存在する場合はこの状態
  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
};

// 評価値
enum Value : int {
  // ゼロ
  VALUE_ZERO = 0,

  // 引き分け
  VALUE_DRAW = 0,
  VALUE_KNOWN_WIN = 15000,

  // 詰み
  VALUE_MATE = 30000,

  // ∞
  VALUE_INFINITE = 30001,

  // それ以外の特殊な定数
  VALUE_NONE = 30002,

  // 即詰みに討ち取れる(このスコア以上ならば)
  VALUE_MATE_IN_MAX_PLY = VALUE_MATE - MAX_PLY,

  // 即詰みに討ち取られる(このスコア以下ならば)
  VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + MAX_PLY,

  // Mg : Midgame中盤のこと
  // Eg : Endgame終盤のこと
  Mg = 0, Eg = 1,

  // 中盤と終盤におけるそれぞれの駒の価値
  PawnValueMg = 198, PawnValueEg = 258,
  KnightValueMg = 817, KnightValueEg = 846,
  BishopValueMg = 836, BishopValueEg = 857,
  RookValueMg = 1270, RookValueEg = 1278,
  QueenValueMg = 2521, QueenValueEg = 2558
};

// 駒の種別
// 先後の区別はない。
// 成り駒の区別もない(チェスには成り駒がないから)
enum PieceType {
  NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,
  ALL_PIECES = 0,
  PIECE_TYPE_NB = 8
};

// 駒
// こちらは先後の区別のある駒を表現する。
enum Piece {
  NO_PIECE,
  W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,
  B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
  PIECE_NB = 16
};

// 手番。
enum Color {
  // 先手, 後手 , 先後なし , 終端
  WHITE, BLACK, NO_COLOR, COLOR_NB = 2
};

// 探索深さ
// ※　Depthへintからの変換子は定義されていない。このため、直接値をDepthなどに代入することは出来ない。
// 0を代入したいときはDEPTH_ZEROを用いる。定数を用いたいときは、
// ONE_PLY * 3　のように用いる。Depthとintの掛け算はのちに定義されている。
enum Depth {

  // 1手の深さ
  ONE_PLY = 2,

  // 0手の深さ
  DEPTH_ZERO = 0 * ONE_PLY,

  // 静止探索の深さ
  DEPTH_QS_CHECKS = 0 * ONE_PLY,
  DEPTH_QS_NO_CHECKS = -1 * ONE_PLY,

  // 静止探索のリキャプチャーの深さ
  DEPTH_QS_RECAPTURES = -5 * ONE_PLY,

  DEPTH_NONE = -127 * ONE_PLY
};

// 盤面上の位置を表現する定数
enum Square {
  // 盤面の左上から右下まで。
  SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1,
  SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,
  SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3,
  SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4,
  SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5,
  SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6,
  SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,
  SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,

  // --- 以下、特殊な定数

  // 盤面の範囲外であることを表すための定数。
  // アンパサンの升や、KINGの初期位置などに用いる。
  SQ_NONE,

  // 盤面のサイズ
  SQUARE_NB = 64,

  // 方角に関する定数。N=北=上を意味する。
  DELTA_N = 8, // 上
  DELTA_E = 1, // 右
  DELTA_S = -8, // 左
  DELTA_W = -1, // 下

  // 斜めの方角などを意味する定数。
  DELTA_NN = DELTA_N + DELTA_N, // 2つ上
  DELTA_NE = DELTA_N + DELTA_E, // 右上
  DELTA_SE = DELTA_S + DELTA_E, // 右下
  DELTA_SS = DELTA_S + DELTA_S, // 2つ下
  DELTA_SW = DELTA_S + DELTA_W, // 左下
  DELTA_NW = DELTA_N + DELTA_W  // 左上
};

// 「筋」(５筋位取りとか言うときの筋)を表現する。
// FILE_NBは終端を表すためのもの。
enum File {
  FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NB
};

// 「段」を表現する。
// RANK_NBは終端を表すためのもの。
enum Rank {
  RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB
};


/// Score enum keeps a midgame and an endgame value in a single integer, first
/// LSB 16 bits are used to store endgame value, while upper bits are used for
/// midgame value.

// 中盤・終盤の評価値はそれぞれ別個に計算するが、単一のint型変数に収めてある。
// 下位16bitは終盤の評価値で、上位16bitは中盤の評価値を格納する。
// ※　将棋で、こんなことをする気がないなら、このScore型は不要。

enum Score : int { SCORE_ZERO };

// 中盤と終盤における駒の価値を引数に取り、Score型を返す関数。
inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }

/// Extracting the signed lower and upper 16 bits it 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, so use a faster code in this case that, although not 100% standard
/// compliant it 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 eg_value(Score s) {
  return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u));
}

#endif

// +,-,*など標準的なoperatorを標準的な方法で定義するためのマクロ
// enumで定義されている型に対して用いる。
#define ENABLE_SAFE_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)); }              \
  inline T operator*(const T d, int i) { return T(int(d) * i); }              \
  inline T operator-(const T d) { return T(-int(d)); }                        \
  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); }

// ENABLE_OPERATORS_ON(T)のほうは上記のENABLE_SAFE_OPERATORS_ON(T)に加えて、++,--,/,/=をサポートしている。
// ほとんどint型同然であるValue,Depthなどに対して用いる。
#define ENABLE_OPERATORS_ON(T) ENABLE_SAFE_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)

/// Added operators for adding integers to a Value
// 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)

/// 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.
// 宣言されているだけで定義はされていない。オーバーフローするリスクが非常に高いので２つのスコアの掛け算をしたくない。
// だから、明示的にint型に変換すべきだ。

inline Score operator*(Score s1, Score s2);

/// Division of a Score must be handled separately for each term
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

extern Value PieceValue[PHASE_NB][PIECE_NB];

// 指し手 + スコアを示す構造体。構造体サイズが64bitなので、スコア順にソートするときに
// 単に64bit整数とみなしてソートすれば良い。 
// →　あかん。そんなことをするとソートの安定性に欠ける。
struct ExtMove {
  Move move;
  int score; // Score型ではないことに注意。
};

// ExtMove同士の比較演算子
inline bool operator<(const ExtMove& f, const ExtMove& s) {
  return f.score < s.score;
}

// 手番(先手,後手)を渡すと、相手番が返る。
inline Color operator~(Color c) {
  return Color(c ^ BLACK);
  // ※　将棋ではWHITEが後手で、これを1にするならBLACKとXORしても仕方がないんだな。
  // ここ、XORするならColor(c ^ (BLACK + WHITE))みたいな実装であるべきなんじゃないかな。
}

// 盤面を上下反転させたときの位置を返す
// ※　SQ_A1→SQ_A8になる。
inline Square operator~(Square s) {
  return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8
}

// 段と列から盤面の位置を返す
inline Square operator|(File f, Rank r) {
  return Square((r << 3) | f);
}

// N手で詰ませられるを表す定数を返す
inline Value mate_in(int ply) {
  return VALUE_MATE - ply;
}

// N手で詰まされるを表す定数を返す
inline Value mated_in(int ply) {
  return -VALUE_MATE + ply;
}

// 手番と駒種によって、その駒を作る。
inline Piece make_piece(Color c, PieceType pt) {
  return Piece((c << 3) | pt);
}

// キャスリング権を作るようだが…
// チェスのルールよくわからん…
inline CastleRight make_castle_right(Color c, CastlingSide s) {
  return CastleRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));
}

// 駒から、駒の種別が返る
// 捕獲する駒によってMVV/LVAするときに使う。
inline PieceType type_of(Piece p)  {
  return PieceType(p & 7);
}

// 駒から、先後どちらの駒かが返る
inline Color color_of(Piece p) {
  assert(p != NO_PIECE);
  return Color(p >> 3);
}

// Square型のsが盤面内を指しているかのチェック用の関数
inline bool is_ok(Square s) {
  return s >= SQ_A1 && s <= SQ_H8;
}

// Square型から筋を得る
inline File file_of(Square s) {
  return File(s & 7);
}

// Square型から列を得る
inline Rank rank_of(Square s) {
  return Rank(s >> 3);
}

// Colorが手番で、先手なら0、後手なら1なので、後手のときだけ56でxorされる。
// 56 = 111000bなので段を意味する3bitを反転させている。
// つまり、後手の場合だけ上下反転。
inline Square relative_square(Color c, Square s) {
  return Square(s ^ (c * 56));
}

// 後手の場合だけ上下反転したRANK(段)を返す。
inline Rank relative_rank(Color c, Rank r) {
  return Rank(r ^ (c * 7));
}

// 升sに対して、先手の場合はRANK(段)をそのまま返す。
// 後手の場合だけ上下反転したRANK(段)を返す。
inline Rank relative_rank(Color c, Square s) {
  return relative_rank(c, rank_of(s));
}

// 盤上をチェッカープレートにみたてて、違う色のところにあるならばtrueが返る。
inline bool opposite_colors(Square s1, Square s2) {
  // s1,s2のxorをとったあと、そのbit3(段数の偶奇)とbit0(列数の偶奇)のxorをとっている。
  int s = int(s1) ^ int(s2);
  return ((s >> 3) ^ s) & 1;
}

// 筋を示す文字を生成する
// tolower == trueなら小文字で。
inline char file_to_char(File f, bool tolower = true) {
  return char(f - FILE_A + (tolower ? 'a' : 'A'));
}

// 段を示す文字を生成する
// tolower == trueなら小文字で。
inline char rank_to_char(Rank r) {
  return char(r - RANK_1 + '1');
}

inline Square pawn_push(Color c) {
  return c == WHITE ? DELTA_N : DELTA_S;
}

// 指し手の移動元の升を返す
inline Square from_sq(Move m) {
  return Square((m >> 6) & 0x3F);
}

// 指し手の移動先の升を返す
inline Square to_sq(Move m) {
  return Square(m & 0x3F);
}

// 指し手Moveから、そのbit14,15であるMoveTypeを得る。
// MoveTypeはbit14,15にそのまま位置している。
inline MoveType type_of(Move m) {
  return MoveType(m & (3 << 14));
}

// 成ったときの駒の種類を返す
// →　チェス独特のルールなので将棋のときは修正せよ。
inline PieceType promotion_type(Move m) {
  return PieceType(((m >> 12) & 3) + 2);
}

// fromからtoに移動する指し手の生成
// これ、成りがないんだな…。
inline Move make_move(Square from, Square to) {
  return Move(to | (from << 6));
}

template<MoveType T>
inline Move make(Square from, Square to, PieceType pt = KNIGHT) {
  return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12));
}

// MOVE_NULLとMOVE_NONEでないことを検証するためのvalidation。
inline bool is_ok(Move m) {
  // MOVE_NULLとMOVE_NONEならば、移動元と移動先が一致する
  return from_sq(m) != to_sq(m); // Catches also MOVE_NULL and MOVE_NONE
}

#include <string>

// 升をそこを示す文字列に変換する。
// ※　こんなもの、速度が要求されるところで使うわけではないのにinlineにする必要があるのか？
inline const std::string square_to_string(Square s) {
  return{ file_to_char(file_of(s)), rank_to_char(rank_of(s)) };
}

#endif // #ifndef TYPES_H_INCLUDED

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

Stockfish, a UCI chess playing engine derived from Glaurung 2.1

Stockfish is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

Stockfish is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see .

#ifndef TYPES_H_INCLUDED

#define TYPES_H_INCLUDED

/// For Linux and OSX configuration is done automatically using Makefile. To get

/// started type 'make help'.

///

/// For Windows, part of the configuration is detected automatically, but some

/// switches need to be set manually:

///

/// -DNDEBUG | Disable debugging mode. Use always.

///

/// -DNO_PREFETCH | Disable use of prefetch asm-instruction. A must if you want

/// | the executable to run on some very old machines.

///

/// -DUSE_POPCNT | Add runtime support for use of popcnt asm-instruction. Works

/// | only in 64-bit mode. For compiling requires hardware with

/// | popcnt support.

// LinuxとOSXの設定は、Makefileによって自動的に行われる。'make help'から始めよ。

// Windowsでは、設定の一部は自動的に検知されるが、いくつかのスイッチは手動でセットする必要がある。

// -DNDEBUG | デバッグモードを無効にする。いつでも使える。

// -DNO_PREFETCH | asm命令であるprefetchを使うのを無効化する。

// もし非常に古いマシンで走らせたいなら必要である。

// -DUSE_POPCNT | asm命令であるpopcnt(SSE4.2から対応)の使用に関してランタイムのサポートを追加する。

// これは64bitモードでのみ動作する。

// このコンパイル(した実行ファイル)はpopcntをサポートしているハードウェアを必要とする。

#include

#if defined(_MSC_VER)

// Disable some silly and noisy warning from MSVC compiler

#pragma warning(disable: 4127) // Conditional expression is constant

#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type

#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'

#endif

#define unlikely(x) (x) // For code annotation purposes

#if defined(_WIN64) && !defined(IS_64BIT)

# include // MSVC popcnt and bsfq instrinsics

# define IS_64BIT

# define USE_BSFQ

#endif

#if defined(USE_POPCNT) && defined(_MSC_VER) && defined(__INTEL_COMPILER)

# include // Intel header for _mm_popcnt_u64() intrinsic

#endif

# if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER))

# include // Intel and Microsoft header for _mm_prefetch()

# endif

// メモリのキャッシュラインのサイズ

// (1バイト目を読み込むと、後続の64バイトが読み込まれる。)

#define CACHE_LINE_SIZE 64

#if defined(_MSC_VER) || defined(__INTEL_COMPILER)

# define CACHE_LINE_ALIGNMENT __declspec(align(CACHE_LINE_SIZE))

#else

# define CACHE_LINE_ALIGNMENT __attribute__ ((aligned(CACHE_LINE_SIZE)))

#endif

// MSVCなのか

#ifdef _MSC_VER

# define FORCE_INLINE __forceinline

#elif defined(__GNUC__)

# define FORCE_INLINE inline __attribute__((always_inline))

#else

# define FORCE_INLINE inline

#endif

// POPCNTを用いるのか。SSE4.2以降。

#ifdef USE_POPCNT

const bool HasPopCnt = true;

#else

const bool HasPopCnt = false;

#endif

// 64bitモード用にコンパイルするのか。

#ifdef IS_64BIT

const bool Is64Bit = true;

#else

const bool Is64Bit = false;

#endif

// 局面のハッシュキー

typedef uint64_t Key;

// 盤面を表すbitboard。チェスは64升なので64bit変数にぴったり収まる。

typedef uint64_t Bitboard;

// ある局面の最大の指し手数

const int MAX_MOVES = 256;

// 探索最大深さ

const int MAX_PLY = 100;

// 探索最大深さ+6 (バッファを余分に確保する用)

const int MAX_PLY_PLUS_6 = MAX_PLY + 6;

/// A move needs 16 bits to be stored

///

/// bit 0- 5: destination square (from 0 to 63)

/// bit 6-11: origin square (from 0 to 63)

/// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2)

/// bit 14-15: special move flag: promotion (1), en passant (2), castle (3)

///

/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in because in

/// any normal move destination square is always different from origin square

/// while MOVE_NONE and MOVE_NULL have the same origin and destination square.

指し手は格納するのに16-bit必要である。

bit 0-5 : 移動先(0から63までの値)

bit 6-11 : 移動元(0から63までの値)

bit 12-13: promotion piece type(成駒の駒種の値)から2を引いた値(KNIGHT-2からQUEEN-2)

bit 14-15: 特殊な移動フラグ : 成り(1) , アンパッサン(2) , キャスリング(3)

特殊な移動値として、MOVE_NONEとMOVE_NULLがある。

普通の指し手は、移動元と移動先とは異なるはずである。(移動していない指し手はないので)

そこで、移動元=0かつ移動先=0だとか、移動元=1かつ移動先=1のような指し手は通常は出現しないので

これを特殊な用途に使うことが出来る。

enum Move {

// 無効な値であることを示す特殊な値。移動元=0,移動先=0

MOVE_NONE,

// null move枝刈りのときに使う特殊な移動の値。移動元=1,移動先=1 ( 1*64 + 1 == 65)

MOVE_NULL = 65

// MOVE_NONE,MOVE_NULLを捕捉するのに

// return from_sq(m) != to_sq(m)

// のように書けるのが唯一の利点なのだが、将棋で、例えば駒打ちをfrom = 駒種にしてしまうと

// そうは書けなくなる。まあ、仕方がないか…。

// is_ok(Move)でしかそんな判定していないしな…。

};

// 移動の種類(Moveのbit14,15のための定数)

enum MoveType {

NORMAL, // 通常移動

PROMOTION = 1 << 14, // 成り

ENPASSANT = 2 << 14, // アンパッサン

CASTLE = 3 << 14 // キャスリング

};

enum CastleRight { // Defined as in PolyGlot book hash key

CASTLES_NONE,

WHITE_OO,

WHITE_OOO = WHITE_OO << 1,

BLACK_OO = WHITE_OO << 2,

BLACK_OOO = WHITE_OO << 3,

ALL_CASTLES = WHITE_OO | WHITE_OOO | BLACK_OO | BLACK_OOO,

CASTLE_RIGHT_NB = 16

};

enum CastlingSide {

KING_SIDE,

QUEEN_SIDE,

CASTLING_SIDE_NB = 2

};

enum Phase {

PHASE_ENDGAME,

PHASE_MIDGAME = 128,

MG = 0, EG = 1, PHASE_NB = 2

};

enum ScaleFactor {

SCALE_FACTOR_DRAW = 0,

SCALE_FACTOR_NORMAL = 64,

SCALE_FACTOR_MAX = 128,

SCALE_FACTOR_NONE = 255

};

// スコア(評価値)がどういう探索の結果得た値なのかを表現する。

enum Bound {

// 探索しておらず、局面の静的評価値か最善手のみを置換表に突っ込みたいときに用いる。

BOUND_NONE,

// fail-lowしたときの状態。この局面のスコアの最大値であり、このnodeの真の評価値はttValue以下である。

// non PV nodeとか、bestMoveがない(適当な見積もりで枝刈りした場合など)は、この状態

BOUND_UPPER,

// fail-highしたときの状態。この局面のスコアの最低保証値であり、このnodeの真の評価値はttValue以上である。

// beta cutしたときに、そのときの値を置換表に格納するときに使う。

// beta cutなので他の残りの指し手に関して、これよりいい評価値のものがあるはずだという意味で使う。

BOUND_LOWER,

// fail-lowもfail-highもしておらず正確なスコアと言える状態

// PvNodeでかつbestMoveが具体的な指し手として存在する場合はこの状態

BOUND_EXACT = BOUND_UPPER | BOUND_LOWER

};

// 評価値

enum Value : int {

// ゼロ

VALUE_ZERO = 0,

// 引き分け

VALUE_DRAW = 0,

VALUE_KNOWN_WIN = 15000,

// 詰み

VALUE_MATE = 30000,

// ∞

VALUE_INFINITE = 30001,

// それ以外の特殊な定数

VALUE_NONE = 30002,

// 即詰みに討ち取れる(このスコア以上ならば)

VALUE_MATE_IN_MAX_PLY = VALUE_MATE - MAX_PLY,

// 即詰みに討ち取られる(このスコア以下ならば)

VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + MAX_PLY,

// Mg : Midgame中盤のこと

// Eg : Endgame終盤のこと

Mg = 0, Eg = 1,

// 中盤と終盤におけるそれぞれの駒の価値

PawnValueMg = 198, PawnValueEg = 258,

KnightValueMg = 817, KnightValueEg = 846,

BishopValueMg = 836, BishopValueEg = 857,

RookValueMg = 1270, RookValueEg = 1278,

QueenValueMg = 2521, QueenValueEg = 2558

};

// 駒の種別

// 先後の区別はない。

// 成り駒の区別もない(チェスには成り駒がないから)

enum PieceType {

NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING,

ALL_PIECES = 0,

PIECE_TYPE_NB = 8

};

// 駒

// こちらは先後の区別のある駒を表現する。

enum Piece {

NO_PIECE,

W_PAWN = 1, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING,

B_PAWN = 9, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,

PIECE_NB = 16

};

// 手番。

enum Color {

// 先手, 後手 , 先後なし , 終端

WHITE, BLACK, NO_COLOR, COLOR_NB = 2

};

// 探索深さ

// ※　Depthへintからの変換子は定義されていない。このため、直接値をDepthなどに代入することは出来ない。

// 0を代入したいときはDEPTH_ZEROを用いる。定数を用いたいときは、

// ONE_PLY * 3　のように用いる。Depthとintの掛け算はのちに定義されている。

enum Depth {

// 1手の深さ

ONE_PLY = 2,

// 0手の深さ

DEPTH_ZERO = 0 * ONE_PLY,

// 静止探索の深さ

DEPTH_QS_CHECKS = 0 * ONE_PLY,

DEPTH_QS_NO_CHECKS = -1 * ONE_PLY,

// 静止探索のリキャプチャーの深さ

DEPTH_QS_RECAPTURES = -5 * ONE_PLY,

DEPTH_NONE = -127 * ONE_PLY

};

// 盤面上の位置を表現する定数

enum Square {

// 盤面の左上から右下まで。

SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1,

SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2,

SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3,

SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4,

SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5,

SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6,

SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7,

SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8,

// --- 以下、特殊な定数

// 盤面の範囲外であることを表すための定数。

// アンパサンの升や、KINGの初期位置などに用いる。

SQ_NONE,

// 盤面のサイズ

SQUARE_NB = 64,

// 方角に関する定数。N=北=上を意味する。

DELTA_N = 8, // 上

DELTA_E = 1, // 右

DELTA_S = -8, // 左

DELTA_W = -1, // 下

// 斜めの方角などを意味する定数。

DELTA_NN = DELTA_N + DELTA_N, // 2つ上

DELTA_NE = DELTA_N + DELTA_E, // 右上

DELTA_SE = DELTA_S + DELTA_E, // 右下

DELTA_SS = DELTA_S + DELTA_S, // 2つ下

DELTA_SW = DELTA_S + DELTA_W, // 左下

DELTA_NW = DELTA_N + DELTA_W // 左上

};

// 「筋」(５筋位取りとか言うときの筋)を表現する。

// FILE_NBは終端を表すためのもの。

enum File {

FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_NB

};

// 「段」を表現する。

// RANK_NBは終端を表すためのもの。

enum Rank {

RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_NB

};

/// Score enum keeps a midgame and an endgame value in a single integer, first

/// LSB 16 bits are used to store endgame value, while upper bits are used for

/// midgame value.

// 中盤・終盤の評価値はそれぞれ別個に計算するが、単一のint型変数に収めてある。

// 下位16bitは終盤の評価値で、上位16bitは中盤の評価値を格納する。

// ※　将棋で、こんなことをする気がないなら、このScore型は不要。

enum Score : int { SCORE_ZERO };

// 中盤と終盤における駒の価値を引数に取り、Score型を返す関数。

inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }

/// Extracting the signed lower and upper 16 bits it 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, so use a faster code in this case that, although not 100% standard

/// compliant it 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 eg_value(Score s) {

return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u));

}

#endif

// +,-,*など標準的なoperatorを標準的な方法で定義するためのマクロ

// enumで定義されている型に対して用いる。

#define ENABLE_SAFE_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)); } \

inline T operator*(const T d, int i) { return T(int(d) * i); } \

inline T operator-(const T d) { return T(-int(d)); } \

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); }

// ENABLE_OPERATORS_ON(T)のほうは上記のENABLE_SAFE_OPERATORS_ON(T)に加えて、++,--,/,/=をサポートしている。

// ほとんどint型同然であるValue,Depthなどに対して用いる。

#define ENABLE_OPERATORS_ON(T) ENABLE_SAFE_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)

/// Added operators for adding integers to a Value

// 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)

/// 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.

// 宣言されているだけで定義はされていない。オーバーフローするリスクが非常に高いので２つのスコアの掛け算をしたくない。

// だから、明示的にint型に変換すべきだ。

inline Score operator*(Score s1, Score s2);

/// Division of a Score must be handled separately for each term

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

extern Value PieceValue[PHASE_NB][PIECE_NB];

// 指し手 + スコアを示す構造体。構造体サイズが64bitなので、スコア順にソートするときに

// 単に64bit整数とみなしてソートすれば良い。

// →　あかん。そんなことをするとソートの安定性に欠ける。

struct ExtMove {

Move move;

int score; // Score型ではないことに注意。

};

// ExtMove同士の比較演算子

inline bool operator<(const ExtMove& f, const ExtMove& s) {

return f.score < s.score;

}

// 手番(先手,後手)を渡すと、相手番が返る。

inline Color operator~(Color c) {

return Color(c ^ BLACK);

// ※　将棋ではWHITEが後手で、これを1にするならBLACKとXORしても仕方がないんだな。

// ここ、XORするならColor(c ^ (BLACK + WHITE))みたいな実装であるべきなんじゃないかな。

}

// 盤面を上下反転させたときの位置を返す

// ※　SQ_A1→SQ_A8になる。

inline Square operator~(Square s) {

return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8

}

// 段と列から盤面の位置を返す

inline Square operator|(File f, Rank r) {

return Square((r << 3) | f);

}

// N手で詰ませられるを表す定数を返す

inline Value mate_in(int ply) {

return VALUE_MATE - ply;

}

// N手で詰まされるを表す定数を返す

inline Value mated_in(int ply) {

return -VALUE_MATE + ply;

}

// 手番と駒種によって、その駒を作る。

inline Piece make_piece(Color c, PieceType pt) {

return Piece((c << 3) | pt);

}

// キャスリング権を作るようだが…

// チェスのルールよくわからん…

inline CastleRight make_castle_right(Color c, CastlingSide s) {

return CastleRight(WHITE_OO << ((s == QUEEN_SIDE) + 2 * c));

}

// 駒から、駒の種別が返る

// 捕獲する駒によってMVV/LVAするときに使う。

inline PieceType type_of(Piece p) {

return PieceType(p & 7);

}

// 駒から、先後どちらの駒かが返る

inline Color color_of(Piece p) {

assert(p != NO_PIECE);

return Color(p >> 3);

}

// Square型のsが盤面内を指しているかのチェック用の関数

inline bool is_ok(Square s) {

return s >= SQ_A1 && s <= SQ_H8;

}

// Square型から筋を得る

inline File file_of(Square s) {

return File(s & 7);

}

// Square型から列を得る

inline Rank rank_of(Square s) {

return Rank(s >> 3);

}

// Colorが手番で、先手なら0、後手なら1なので、後手のときだけ56でxorされる。

// 56 = 111000bなので段を意味する3bitを反転させている。

// つまり、後手の場合だけ上下反転。

inline Square relative_square(Color c, Square s) {

return Square(s ^ (c * 56));

}

// 後手の場合だけ上下反転したRANK(段)を返す。

inline Rank relative_rank(Color c, Rank r) {

return Rank(r ^ (c * 7));

}

// 升sに対して、先手の場合はRANK(段)をそのまま返す。

// 後手の場合だけ上下反転したRANK(段)を返す。

inline Rank relative_rank(Color c, Square s) {

return relative_rank(c, rank_of(s));

}

// 盤上をチェッカープレートにみたてて、違う色のところにあるならばtrueが返る。

inline bool opposite_colors(Square s1, Square s2) {

// s1,s2のxorをとったあと、そのbit3(段数の偶奇)とbit0(列数の偶奇)のxorをとっている。

int s = int(s1) ^ int(s2);

return ((s >> 3) ^ s) & 1;

}

// 筋を示す文字を生成する

// tolower == trueなら小文字で。

inline char file_to_char(File f, bool tolower = true) {

return char(f - FILE_A + (tolower ? 'a' : 'A'));

}

// 段を示す文字を生成する

// tolower == trueなら小文字で。

inline char rank_to_char(Rank r) {

return char(r - RANK_1 + '1');

}

inline Square pawn_push(Color c) {

return c == WHITE ? DELTA_N : DELTA_S;

}

// 指し手の移動元の升を返す

inline Square from_sq(Move m) {

return Square((m >> 6) & 0x3F);

}

// 指し手の移動先の升を返す

inline Square to_sq(Move m) {

return Square(m & 0x3F);

}

// 指し手Moveから、そのbit14,15であるMoveTypeを得る。

// MoveTypeはbit14,15にそのまま位置している。

inline MoveType type_of(Move m) {

return MoveType(m & (3 << 14));

}

// 成ったときの駒の種類を返す

// →　チェス独特のルールなので将棋のときは修正せよ。

inline PieceType promotion_type(Move m) {

return PieceType(((m >> 12) & 3) + 2);

}

// fromからtoに移動する指し手の生成

// これ、成りがないんだな…。

inline Move make_move(Square from, Square to) {

return Move(to | (from << 6));

}

template

inline Move make(Square from, Square to, PieceType pt = KNIGHT) {

return Move(to | (from << 6) | T | ((pt - KNIGHT) << 12));

}

// MOVE_NULLとMOVE_NONEでないことを検証するためのvalidation。

inline bool is_ok(Move m) {

// MOVE_NULLとMOVE_NONEならば、移動元と移動先が一致する

return from_sq(m) != to_sq(m); // Catches also MOVE_NULL and MOVE_NONE

}

#include

// 升をそこを示す文字列に変換する。

// ※　こんなもの、速度が要求されるところで使うわけではないのにinlineにする必要があるのか？

inline const std::string square_to_string(Square s) {

return{ file_to_char(file_of(s)), rank_to_char(rank_of(s)) };

}

#endif // #ifndef TYPES_H_INCLUDED

「Stockfish DD – types.h」への5件のフィードバック

わるお 2015年8月30日 17:23 より:

stockfishやaperyでは定数をenumで定義し、そのenumに対してのみ使う関数（PieceType type_of(Piece)など）をグローバルな位置に定義していることが多いように見受けられるのですが、クラスにしないのはなぜでしょうか？特にPiece型,PieceType型はクラス化したほうがわかりやすくなると思うのですが。

返信 ↓
- やねうらお 2015年8月30日 18:12 より:
  
  classにすると何らかの条件が組み合わさったときに最適化が阻害されることがよくありまして…。
  
  返信 ↓
  - わるお 2015年8月30日 18:20 より:
    
    すばやい返信ありがとうございます。
    最適化の阻害ですか。どういう条件なのでしょうか。単純にソースにenum型を埋め込むのとclassのgetterを呼び出すのに違いが出たりするということでしょうか？
    
    返信 ↓
    - やねうらお 2015年8月30日 20:10 より:
      
      色んなところで違いが出ますね。コードの意味的には等価なはずでも、ほとんどのコンパイラで異なるコードが生成されるかと思います。最近のコンパイラではどうだかわかりませんが…。
      
      そんなわけで、賢明なC++プログラマは、地雷を避けるためにenumを使うのでは…。
      
      返信 ↓
      - わるお 2015年8月30日 21:54 より:
        
        color_of(piece)という書き方を見ているとどうしてもpiece.color()と書きたくなってしまいます。しかし速度に影響が出るのは嫌ですね。なるほど、ありがとうございます。

やねうら王公式サイト

コンピューター将棋やねうら王公式サイト

Stockfish DD – types.h

「Stockfish DD – types.h」への5件のフィードバック

コメントを残すコメントをキャンセル

「Stockfish DD – types.h」への5件のフィードバック

コメントを残す コメントをキャンセル

コメントを残すコメントをキャンセル