All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
openMidEndingEval.cc
Go to the documentation of this file.
7 #include "osl/eval/ml/mobility.h"
9 #include "osl/eval/ml/pin.h"
10 #include "osl/eval/ml/king8.h"
11 #include "osl/eval/ml/progress.h"
12 #include "osl/effect_util/pin.h"
14 #include "osl/misc/random.h"
15 #include "osl/misc/binaryIO.h"
16 #include "osl/oslConfig.h"
17 #include "osl/pieceStand.h"
18 
19 #include <boost/foreach.hpp>
20 #include <boost/thread/mutex.hpp>
21 #include <fstream>
22 
25 {
26  const CArray<int, PTYPE_SIZE> values = {{
27  0, 0,
28  583, 493, 491, 467, 1279, 1351,
30  128, 318, 361, 540, 959, 1059
31  }};
32  reset(values);
33 }
34 #ifndef MINIMAL
35 const char * osl::eval::ml::
37 {
38  static const CArray<const char *,PROGRESS_INDEPENDENT_FEATURE_LIMIT> table = {{
39  "PIECE",
40  "BISHOP_EXCHANGE_SILVER_KING",
41  "ENTER_KING_DEFENSE",
42  "KING25_EFFECT_ATTACK",
43  "PIECE_PAIR",
44  "PIECE_PAIR_KING",
45  }};
46  return table[f];
47 }
48 const char *osl::eval::ml::
50 {
51  static const CArray<const char *,STAGE_FEATURE_LIMIT> table = {{
52  "KING_PIECE_RELATIVE",
53  "PIECE_STAND",
54  "KING25_EFFECT_EACH",
55  "PTYPEX",
56  "PTYPEY",
57  "ROOK_MOBILITY",
58  "BISHOP_MOBILITY",
59  "LANCE_MOBILITY",
60  "ROOK_EFFECT",
61  "BISHOP_EFFECT",
62  "PIECE_STAND_COMBINATION",
63  "PIECE_STAND_TURN",
64  "ROOK_PAWN",
65  "PAWN_DROP",
66  "PIECE_STAND_Y",
67  "KNIGHT_CHECK",
68  "PAWN_ADVANCE",
69  "PAWN_PTYPEO",
70  "PROMOTED_MINOR_PIECE",
71  "KING_PIECE_RELATIVE_NOSUPPORT",
72  "NON_PAWN_ATTACKED",
73  "NON_PAWN_ATTACKED_PTYPE",
74  "PTYPE_YY",
75  "KING3PIECES",
76  "BISHOP_HEAD",
77  "KNIGHT_HEAD",
78  "ROOK_PROMOTE_DEFENSE",
79  "PTYPE_COUNT",
80  "LANCE_EFFECT_PIECE",
81  "PTYPE_Y_PAWN_Y",
82  "BISHOP_AND_KING",
83  "PIECE_FORK_TURN",
84  "ROOK_SILVER_KNIGHT",
85  "BISHOP_SILVER_KNIGHT",
86  "KING25_EFFECT_SUPPORTED",
87  "KING_ROOK_BISHOP",
88  "KING_X_BLOCKED3",
89  "GOLD_RETREAT",
90  "SILVER_RETREAT",
91  "ALL_GOLD",
92  "ALL_MAJOR",
93  "KING25_EFFECT_DEFENSE",
94  "ANAGUMA_EMPTY",
95  "NO_PAWN_ON_STAND",
96  "NON_PAWN_PIECE_STAND",
97  "PIN_PTYPE_ALL",
98  "KING_MOBILITY",
99  "GOLD_AND_SILVER_NEAR_KING",
100  "PTYPE_COMBINATION",
101  "KING25_BOTH_SIDE",
102  "KING25_MOBILITY",
103  "BISHOP_STAND_FILE5",
104  "MAJOR_CHECK_WITH_CAPTURE",
105  "SILVER_ADVANCE26",
106  "KING25_EFFECT3",
107  "BISHOP_BISHOP_PIECE",
108  "ROOK_ROOK",
109  "ROOK_ROOK_PIECE",
110  "KING25_EFFECT_COUNT_COMBINATION",
111  "NON_PAWN_ATTACKED_PTYPE_PAIR",
112  "ATTACK_MAJORS_IN_BASE",
113  }};
114  return table[f];
115 }
116 #endif
117 
120 static boost::mutex initialize_mutex;
123 namespace
124 {
125 #ifndef MINIMAL
126  template <class Eval>
127  static void setRandomOne()
128  {
129  osl::eval::ml::Weights weights(Eval::DIM);
130  for (size_t i = 0; i < weights.dimension(); ++i)
131  {
132  weights.setValue(i, (osl::misc::random() % 1024)-512);
133  }
134  Eval::setUp(weights);
135  }
136  template <class Eval>
137  static void setRandomOne(int stage)
138  {
139  osl::eval::ml::Weights weights(Eval::DIM);
140  for (size_t i = 0; i < weights.dimension(); ++i)
141  {
142  weights.setValue(i, (osl::misc::random() % 1024)-512);
143  }
144  Eval::setUp(weights, stage);
145  }
146 #endif
147  template <class Eval, class Reader>
148  static int setUpOneWithDim(Reader& p, int dim)
149  {
150  osl::eval::ml::Weights weights(dim);
151  // std::cerr << typeid(Eval).name() << " " << dim << "\n";
152  for (size_t i = 0; i < weights.dimension(); ++i)
153  {
154  if (! p.hasNext())
155  break;
156  int val = p.read();
157  weights.setValue(i, val);
158  }
159  Eval::setUp(weights);
160  return weights.dimension();
161  }
162  template <class Eval, class Reader>
163  static int setUpOne(Reader& p)
164  {
165  return setUpOneWithDim<Eval>(p, Eval::DIM);
166  }
167  template <class Eval, class Reader>
168  static int setUpOne(Reader& p, int stage)
169  {
170  osl::eval::ml::Weights weights(Eval::DIM);
171  // std::cerr << typeid(Eval).name() << " " << Eval::DIM << "\n";
172  for (size_t i = 0; i < weights.dimension(); ++i)
173  {
174  if (!p.hasNext())
175  break;
176  int val = p.read();
177  weights.setValue(i, val);
178  }
179  Eval::setUp(weights,stage);
180  return weights.dimension();
181  }
182 }
183 
184 namespace osl
185 {
187  {
188  size_t cur, length;
189  const int *array;
190  IntArrayReader(const int *a, size_t l) : cur(0), length(l), array(a)
191  {
192  }
193  bool hasNext() const { return cur < length; }
194  bool failed() const { return false; }
195  int read() { return array[cur++]; }
196  };
197 }
198 
199 void osl::eval::ml::
201 {
202  IntArrayReader reader(w, length);
203  doResetWeights(reader);
204 }
205 
206 bool osl::eval::ml::OpenMidEndingEval::setUp(const char *filename)
207 {
208  boost::mutex::scoped_lock lk(initialize_mutex);
209  if (initialized_flag == Loaded)
210  return true;
211  typedef osl::misc::BinaryElementReader<int> reader_t;
212  std::ifstream is(filename, std::ios_base::binary);
213  reader_t reader(is);
214  if (! reader.hasNext()) {
215  initialized_flag = Zero;
216  std::cerr << "file " << filename << std::endl;
217  return false;
218  }
219  doResetWeights(reader);
220  return initialized_flag == Loaded;
221 }
222 
223 template <class Reader>
224 void osl::eval::ml::
226 {
227  size_t read_count = 0;
228 
229  // flat
230  CArray<int, PTYPE_SIZE> piece_values = {{0}};
231  Weights weights(PTYPE_SIZE);
232  for (int i = 0; i < PTYPE_SIZE; ++i)
233  {
234  if (! reader.hasNext())
235  break;
236  int val = reader.read();
237  if (i == KING) {
238  assert(val == 0);
240  }
241  weights.setValue(i, val);
242  piece_values[i] = val;
243  ++read_count;
244  }
245  PieceEval::setUp(weights);
246  Piece_Value.reset(piece_values);
247 
248  PiecePair::init();
249  piece_pair_weights.resetDimension(PiecePair::DIM);
250  for (size_t i = 0; i < piece_pair_weights.dimension(); ++i)
251  {
252  if (! reader.hasNext())
253  break;
254  int val = reader.read();
255  piece_pair_weights.setValue(i, val);
256  ++read_count;
257  }
258  PiecePair::sanitize(piece_pair_weights);
259  PiecePair::compile(piece_pair_weights);
260 
261  read_count += setUpOne<King25EffectAttack>(reader);
262  read_count += setUpOne<King25EffectYAttack>(reader);
263  read_count += setUpOne<PiecePairKing>(reader);
264  read_count += setUpOne<BishopExchangeSilverKing>(reader);
265  read_count += setUpOne<EnterKingDefense>(reader);
266 
267  // opening
268  read_count += setUpOne<PieceStand>(reader,0);
269  read_count += setUpOne<King25EffectEachBothOpening>(reader);
270  read_count += setUpOne<PawnDrop>(reader,0);
271  read_count += setUpOne<NoPawnOnStand>(reader,0);
272  read_count += setUpOne<GoldRetreat>(reader,0);
273  read_count += setUpOne<SilverRetreat>(reader,0);
274  read_count += setUpOne<KnightAdvance>(reader,0);
275  read_count += setUpOne<AllMajor>(reader,0);
276  read_count += setUpOne<KingXBlocked>(reader,0);
277  read_count += setUpOne<KingXBlockedY>(reader,0);
278  read_count += setUpOne<AllGold>(reader,0);
279  read_count += setUpOne<PtypeX>(reader,0);
280  read_count += setUpOne<PtypeY>(reader,0);
281  read_count += setUpOne<AnagumaEmpty>(reader,0);
282  read_count += setUpOne<NonPawnPieceStand>(reader,0);
283  read_count += setUpOne<King25EffectDefense>(reader,0);
284  read_count += setUpOne<King25EffectYDefense>(reader,0);
285  read_count += setUpOne<RookMobility>(reader,0);
286  read_count += setUpOne<BishopMobility>(reader,0);
287  read_count += setUpOne<LanceMobility>(reader,0);
288  read_count += setUpOne<RookEffect>(reader,0);
289  read_count += setUpOne<BishopEffect>(reader,0);
290  read_count += setUpOne<PawnAdvance>(reader,0);
291  read_count += setUpOne<PawnDropY>(reader,0);
292  read_count += setUpOne<KnightCheck>(reader,0);
293 
294  // midgame
295  read_count += setUpOne<PieceStand>(reader,1);
296  read_count += setUpOne<King25EffectEachBothMidgame>(reader);
297  read_count += setUpOne<PawnDrop>(reader,1);
298  read_count += setUpOne<NoPawnOnStand>(reader,1);
299  read_count += setUpOne<GoldRetreat>(reader,1);
300  read_count += setUpOne<SilverRetreat>(reader,1);
301  read_count += setUpOne<KnightAdvance>(reader,1);
302  read_count += setUpOne<AllMajor>(reader,1);
303  read_count += setUpOne<KingXBlocked>(reader,1);
304  read_count += setUpOne<KingXBlockedY>(reader,1);
305  read_count += setUpOne<AllGold>(reader,1);
306  read_count += setUpOne<PtypeX>(reader,1);
307  read_count += setUpOne<PtypeY>(reader,1);
308  read_count += setUpOne<AnagumaEmpty>(reader,1);
309  read_count += setUpOne<NonPawnPieceStand>(reader,1);
310  read_count += setUpOne<King25EffectDefense>(reader,1);
311  read_count += setUpOne<King25EffectYDefense>(reader,1);
312  read_count += setUpOne<RookMobility>(reader,1);
313  read_count += setUpOne<BishopMobility>(reader,1);
314  read_count += setUpOne<LanceMobility>(reader,1);
315  read_count += setUpOne<RookEffect>(reader,1);
316  read_count += setUpOne<BishopEffect>(reader,1);
317  read_count += setUpOne<PawnAdvance>(reader,1);
318  read_count += setUpOne<PawnDropY>(reader,1);
319  read_count += setUpOne<KnightCheck>(reader,1);
320 
321 #ifdef EVAL_QUAD
322  // midgame2
323  read_count += setUpOne<PieceStand>(reader,2);
324  read_count += setUpOne<King25EffectEachBothMidgame2>(reader);
325  read_count += setUpOne<PawnDrop>(reader,2);
326  read_count += setUpOne<NoPawnOnStand>(reader,2);
327  read_count += setUpOne<GoldRetreat>(reader,2);
328  read_count += setUpOne<SilverRetreat>(reader,2);
329  read_count += setUpOne<KnightAdvance>(reader,2);
330  read_count += setUpOne<AllMajor>(reader,2);
331  read_count += setUpOne<KingXBlocked>(reader,2);
332  read_count += setUpOne<KingXBlockedY>(reader,2);
333  read_count += setUpOne<AllGold>(reader,2);
334  read_count += setUpOne<PtypeX>(reader,2);
335  read_count += setUpOne<PtypeY>(reader,2);
336  read_count += setUpOne<AnagumaEmpty>(reader,2);
337  read_count += setUpOne<NonPawnPieceStand>(reader,2);
338  read_count += setUpOne<King25EffectDefense>(reader,2);
339  read_count += setUpOne<King25EffectYDefense>(reader,2);
340  read_count += setUpOne<RookMobility>(reader,2);
341  read_count += setUpOne<BishopMobility>(reader,2);
342  read_count += setUpOne<LanceMobility>(reader,2);
343  read_count += setUpOne<RookEffect>(reader,2);
344  read_count += setUpOne<BishopEffect>(reader,2);
345  read_count += setUpOne<PawnAdvance>(reader,2);
346  read_count += setUpOne<PawnDropY>(reader,2);
347  read_count += setUpOne<KnightCheck>(reader,2);
348 #endif
349 
350  // endgame
351  read_count += setUpOne<PieceStand>(reader,EndgameIndex);
352  read_count += setUpOne<King25EffectEachBothEnding>(reader);
353  read_count += setUpOne<PawnDrop>(reader,EndgameIndex);
354  read_count += setUpOne<NoPawnOnStand>(reader,EndgameIndex);
355  read_count += setUpOne<GoldRetreat>(reader,EndgameIndex);
356  read_count += setUpOne<SilverRetreat>(reader,EndgameIndex);
357  read_count += setUpOne<KnightAdvance>(reader,EndgameIndex);
358  read_count += setUpOne<AllMajor>(reader,EndgameIndex);
359  read_count += setUpOne<KingXBlocked>(reader,EndgameIndex);
360  read_count += setUpOne<KingXBlockedY>(reader,EndgameIndex);
361  read_count += setUpOne<AllGold>(reader,EndgameIndex);
362  read_count += setUpOne<PtypeX>(reader,EndgameIndex);
363  read_count += setUpOne<PtypeY>(reader,EndgameIndex);
364  read_count += setUpOne<AnagumaEmpty>(reader,EndgameIndex);
365  read_count += setUpOne<NonPawnPieceStand>(reader,EndgameIndex);
366  read_count += setUpOne<King25EffectDefense>(reader,EndgameIndex);
367  read_count += setUpOne<King25EffectYDefense>(reader,EndgameIndex);
368  read_count += setUpOne<RookMobility>(reader,EndgameIndex);
369  read_count += setUpOne<BishopMobility>(reader,EndgameIndex);
370  read_count += setUpOne<LanceMobility>(reader,EndgameIndex);
371  read_count += setUpOne<RookEffect>(reader,EndgameIndex);
372  read_count += setUpOne<BishopEffect>(reader,EndgameIndex);
373  read_count += setUpOne<PawnAdvance>(reader,EndgameIndex);
374  read_count += setUpOne<PawnDropY>(reader,EndgameIndex);
375  read_count += setUpOne<KnightCheck>(reader,EndgameIndex);
376 
377  // triple
378  read_count += setUpOne<KingPieceRelative>(reader,0);
379  read_count += setUpOne<KingPieceRelative>(reader,1);
380 #ifdef EVAL_QUAD
381  read_count += setUpOne<KingPieceRelative>(reader,2);
382 #endif
383  read_count += setUpOne<KingPieceRelative>(reader,EndgameIndex);
384  read_count += setUpOne<NonPawnPieceStandTurn>(reader);
385  read_count += setUpOne<King25EffectEachXY>(reader);
386  read_count += setUpOne<RookPawnY>(reader);
387  read_count += setUpOne<RookEffectPiece>(reader);
388  read_count += setUpOne<BishopEffectPiece>(reader);
389  read_count += setUpOne<PieceStandY>(reader);
390  read_count += setUpOne<RookEffectPieceKingRelative>(reader);
391  read_count += setUpOne<BishopEffectPieceKingRelative>(reader);
392  read_count += setUpOne<RookPawnYX>(reader);
393  read_count += setUpOne<PawnPtypeOPtypeO>(reader);
394  read_count += setUpOne<PromotedMinorPieces>(reader);
395  read_count += setUpOne<KingPieceRelativeNoSupport>(reader);
396  read_count += setUpOne<NonPawnAttacked>(reader);
397  read_count += setUpOne<PtypeYY>(reader);
398  read_count += setUpOne<PawnPtypeOPtypeOY>(reader);
399  read_count += setUpOne<PawnDropX>(reader);
400  read_count += setUpOne<King3Pieces>(reader);
401  read_count += setUpOne<King3PiecesXY>(reader);
402  read_count += setUpOne<King25EffectEachKXY>(reader);
403  read_count += setUpOne<BishopHead>(reader);
404  read_count += setUpOne<BishopHeadKingRelative>(reader);
405  read_count += setUpOne<KnightCheckY>(reader);
406  read_count += setUpOne<KnightHead>(reader);
407  read_count += setUpOne<RookPromoteDefense>(reader);
408  read_count += setUpOne<PawnDropPawnStand>(reader);
409  read_count += setUpOne<PawnDropPawnStandX>(reader);
410  read_count += setUpOne<PawnDropPawnStandY>(reader);
411  read_count += setUpOne<KnightHeadOppPiecePawnOnStand>(reader);
412  read_count += setUpOne<KingXBothBlocked>(reader);
413  read_count += setUpOne<KingXBothBlockedY>(reader);
414  read_count += setUpOne<KingRookBishop>(reader);
415  read_count += setUpOne<PromotedMinorPiecesY>(reader);
416  read_count += setUpOne<King25EffectSupported>(reader);
417  read_count += setUpOne<King25EffectSupportedY>(reader);
418  read_count += setUpOne<NonPawnAttackedKingRelative>(reader);
419  read_count += setUpOne<NonPawnAttackedPtype>(reader);
420  read_count += setUpOne<PtypeCount>(reader);
421  read_count += setUpOne<KingXBlocked3>(reader);
422  read_count += setUpOne<KingXBlocked3Y>(reader);
423  read_count += setUpOne<PtypeCountXY>(reader);
424  read_count += setUpOne<PtypeCountXYAttack>(reader);
425  read_count += setUpOne<LanceEffectPieceKingRelative>(reader);
426  read_count += setUpOne<KingMobility>(reader);
427  read_count += setUpOne<KingMobilitySum>(reader);
428  read_count += setUpOne<PtypeYPawnY>(reader);
429  read_count += setUpOne<GoldAndSilverNearKing>(reader);
430  read_count += setUpOne<PtypeCombination>(reader);
431  read_count += setUpOne<PieceStandCombinationBoth>(reader);
432  read_count += setUpOne<King25BothSide>(reader);
433  read_count += setUpOne<King25BothSideX>(reader);
434  read_count += setUpOne<King25BothSideY>(reader);
435  read_count += setUpOne<GoldAndSilverNearKingCombination>(reader);
436  read_count += setUpOne<KingMobilityWithRook>(reader);
437  read_count += setUpOne<KingMobilityWithBishop>(reader);
438  read_count += setUpOne<NumPiecesBetweenBishopAndKingSelf>(reader);
439  read_count += setUpOne<NumPiecesBetweenBishopAndKingOpp>(reader);
440  read_count += setUpOne<NumPiecesBetweenBishopAndKingAll>(reader);
441  read_count += setUpOne<King25Effect3>(reader);
442  read_count += setUpOne<SilverHeadPawnKingRelative>(reader);
443  read_count += setUpOne<GoldKnightKingRelative>(reader);
444  read_count += setUpOne<RookMobilitySum>(reader);
445  read_count += setUpOne<RookMobilityX>(reader);
446  read_count += setUpOne<RookMobilityY>(reader);
447  read_count += setUpOne<RookMobilitySumKingX>(reader);
448  read_count += setUpOne<RookMobilityXKingX>(reader);
449  read_count += setUpOne<PinPtype>(reader);
450  read_count += setUpOne<PinPtypeDistance>(reader);
451  read_count += setUpOne<BishopMobilityEach>(reader);
452  read_count += setUpOne<BishopBishopPiece>(reader);
453  read_count += setUpOne<NonPawnPieceStandCombination>(reader);
454  read_count += setUpOne<CanCheckNonPawnPieceStandCombination>(reader);
455  read_count += setUpOne<King25Effect3Y>(reader);
456  read_count += setUpOne<RookRook>(reader);
457  read_count += setUpOne<RookRookPiece>(reader);
458  read_count += setUpOne<PinPtypePawnAttack>(reader);
459  read_count += setUpOne<King25Mobility>(reader);
460  read_count += setUpOne<King25MobilityX>(reader);
461  read_count += setUpOne<King25MobilityY>(reader);
462  read_count += setUpOne<King25EffectCountCombination>(reader);
463  read_count += setUpOne<GoldSideMove>(reader);
464  read_count += setUpOne<King25EffectCountCombinationY>(reader);
465  read_count += setUpOne<RookPromoteDefenseRookH>(reader);
466  read_count += setUpOne<BishopHeadX>(reader);
467  read_count += setUpOne<PawnDropNonDrop>(reader);
468  read_count += setUpOne<PawnStateKingRelative>(reader);
469  read_count += setUpOne<SilverFork>(reader);
470  read_count += setUpOne<BishopRookFork>(reader);
471  read_count += setUpOne<BishopStandFile5>(reader);
472  read_count += setUpOne<KnightFork>(reader);
473  read_count += setUpOne<NonPawnAttackedPtypePair>(reader);
474  read_count += setUpOne<MajorCheckWithCapture>(reader);
475  read_count += setUpOne<SilverAdvance26>(reader);
476  read_count += setUpOne<RookSilverKnight>(reader);
477  read_count += setUpOne<BishopSilverKnight>(reader);
478  read_count += setUpOne<AttackMajorsInBase>(reader);
479  read_count += setUpOne<CheckShadowPtype>(reader);
480  read_count += setUpOne<Promotion37>(reader);
481 
482  initialized_flag = reader.failed() ? Zero : Loaded;
483  if (initialized_flag != Loaded)
484  {
485  std::cerr << "Failed to load OpenMidEndingEval data "
486  << ' ' << read_count << std::endl;
487  }
488 }
489 
491 {
492  std::string filename = OslConfig::home();
493  filename += "/data/eval.bin";
494  return filename;
495 }
496 
498 {
499  return setUp(defaultFilename().c_str());
500 }
501 
503 OpenMidEndingEval::OpenMidEndingEval(const NumEffectState &state, bool use_limit)
504  : progress(state), use_progress_independent_value_limit(use_limit)
505 {
506  assert(initialized_flag != Zero);
507 
508  pawns.fill(0);
509  black_pawn_count = 0;
510  turn = state.turn();
511  for (int i = PtypeTraits<PAWN>::indexMin;
512  i < PtypeTraits<PAWN>::indexLimit; ++i)
513  {
514  const Piece pawn = state.pieceOf(i);
515  if (pawn.owner() == BLACK)
517  if (pawn.isOnBoard() && !pawn.isPromoted())
518  pawns[pawn.owner()][pawn.square().x() - 1] =
519  pawn.square().y();
520  }
521  black_major_count = 0;
522  black_gold_count = 0;
523  for (int i = PtypeTraits<ROOK>::indexMin;
524  i < PtypeTraits<ROOK>::indexLimit; ++i)
525  {
526  if (state.pieceOf(i).owner() == BLACK)
528  }
529  for (int i = PtypeTraits<BISHOP>::indexMin;
530  i < PtypeTraits<BISHOP>::indexLimit; ++i)
531  {
532  if (state.pieceOf(i).owner() == BLACK)
534  }
535  for (int i = PtypeTraits<GOLD>::indexMin;
536  i < PtypeTraits<GOLD>::indexLimit; ++i)
537  {
538  if (state.pieceOf(i).owner() == BLACK)
540  }
542 
543  ptype_count.fill(0);
544  ptypeo_mask=0u;
545  ptype_board_count.fill(0);
546  for (int i = 0; i < Piece::SIZE; ++i)
547  {
548  const Piece piece = state.pieceOf(i);
549  if (piece.ptype() == KING)
550  continue;
551  ++ptype_count[piece.owner()][piece.ptype()];
552  ptypeo_mask |= 1<<(piece.ptypeO()-PTYPEO_MIN);
553  if (piece.isOnBoard())
554  ++ptype_board_count[piece.owner()][piece.ptype()];
555  }
556  non_pawn_stand_count.fill(0);
557  BOOST_FOREACH(Ptype ptype, osl::PieceStand::order)
558  {
559  if (ptype == PAWN)
560  continue;
562  state.countPiecesOnStand(osl::BLACK, ptype);
564  state.countPiecesOnStand(osl::WHITE, ptype);
565  }
574 
577 
579 
580  King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[WHITE],
587  King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[BLACK],
588  effect25_supported[BLACK],
596  EnterKingDefense::eval(state) +
598  black_attack_effect,
599  black_attack_piece,
600  white_attack_effect, white_attack_piece);
601  recalculated_value +=
603  black_attack_effect,
604  black_attack_piece,
605  white_attack_effect, white_attack_piece);
607  {
608  MultiInt result_supported =
609  King25EffectSupported::eval(black_attack_piece,
610  white_attack_piece,
611  black_attack_supported_piece,
612  white_attack_supported_piece);
613  MultiInt result_supported_y =
614  King25EffectSupportedY::eval(black_attack_piece,
615  white_attack_piece,
616  black_attack_supported_piece,
617  white_attack_supported_piece,
618  state.kingSquare<BLACK>().y(),
619  state.kingSquare<WHITE>().y());
620 
621  recalculated_stage_value = result_supported + result_supported_y;
622  king_rook_bishop[BLACK]=KingRookBishop::evalOne<BLACK>(state);
623  king_rook_bishop[WHITE]=KingRookBishop::evalOne<WHITE>(state);
624  recalculated_stage_value+=king_rook_bishop[BLACK]-king_rook_bishop[WHITE];
625  recalculated_stage_value+=KingXBlocked3::eval(state);
626  }
627 
629  const MultiInt silver_retreat = SilverFeatures::eval(state);
630  const MultiInt gold_retreat = GoldFeatures::eval(state);
632  recalculated_stage_value += silver_retreat + gold_retreat;
636  King25EffectDefense::eval(state,black_defense_effect,black_defense_piece,
637  white_defense_effect, white_defense_piece);
640  black_defense_effect,
641  black_defense_piece,
642  white_defense_effect, white_defense_piece);
645 
654  king25_both_side[BLACK]=King25BothSide::evalOne<BLACK>(state,black_vertical);
655  king25_both_side[WHITE]=King25BothSide::evalOne<WHITE>(state,white_vertical);
656  recalculated_stage_value += king25_both_side[BLACK]-king25_both_side[WHITE];
657  recalculated_stage_value += King25Mobility::eval(state,
660  recalculated_stage_value += BishopStandFile5::eval(state);
661  recalculated_stage_value += MajorCheckWithCapture::eval(state);
662  recalculated_stage_value += SilverAdvance26::eval(state);
663 
665 
666  pawn_drop = PawnDropBoth::eval(state);
667 
668  ptypex = PtypeX::eval(state);
669 
670  ptypey = PtypeY::eval(state);
671 
672  can_check[BLACK] =
673  CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(state);
674  can_check[WHITE] =
675  CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(state);
677  can_check);
679  rook_pawn = RookPawnY::eval(state, pawns);
681 
685 
687 
690  state.effectedMask(BLACK);
693  state.effectedMask(WHITE);
694  mask_t black_ppawn =
695  effected_mask_for_attacked[BLACK].selectBit<PAWN>() &
696  state.promotedPieces().getMask<PAWN>();
697  mask_t white_ppawn =
698  effected_mask_for_attacked[WHITE].selectBit<PAWN>() &
699  state.promotedPieces().getMask<PAWN>();
707  knight_head = KnightHead::eval(state);
708 
709  ptype_yy = PtypeYY::eval(state);
711  bishop_head = BishopHead::eval(state);
717  recalculated_stage_value += King25Effect3::eval(state, effect25);
718  recalculated_stage_value += BishopBishopPiece::eval(state);
719  recalculated_stage_value += RookRook::eval(state);
720  recalculated_stage_value += RookRookPiece::eval(state);
721  recalculated_stage_value += King25EffectCountCombination::eval(state, effect25);
722  recalculated_stage_value += NonPawnAttackedPtypePair::eval(state);
725  recalculated_stage_value += AttackMajorsInBase::eval(state);
726  recalculated_stage_value += CheckShadowPtype::eval(state);
727  recalculated_stage_value += Promotion37::eval(state);
731  invalidateCache();
732 }
733 
734 int osl::eval::ml::
735 OpenMidEndingEval::expect(const NumEffectState &state, Move move) const
736 {
737  if (move.isPass())
738  return value();
739  int value;
740  if(move.player()==BLACK)
741  value = PieceEval::evalWithUpdate<BLACK>(state, move, progress_independent_value);
742  else
743  value = PieceEval::evalWithUpdate<WHITE>(state, move, progress_independent_value);
744 
745 #ifdef USE_TEST_PROGRESS
746  return roundUp(value * NewProgress::maxProgress() +
747  openingValue() * (NewProgress::maxProgress() - progress.progress()) +
748  endgameValue() * progress.progress());
749 #else
750  return roundUp(value * 16 +
751  openingValue() * (16 - progress.progress16().value()) +
752  endgameValue() * progress.progress16().value());
753 #endif
754 }
755 
756 void osl::eval::ml::
757 OpenMidEndingEval::update(const NumEffectState &new_state, Move last_move)
758 {
759  turn = alt(turn);
760  assert(new_state.turn() == turn);
761  if (last_move.isPass())
762  {
763  invalidateCache();
764  return;
765  }
766  if(last_move.player()==BLACK)
767  updateSub<BLACK>(new_state,last_move);
768  else
769  updateSub<WHITE>(new_state,last_move);
770 }
771 template<osl::Player P>
772 void osl::eval::ml::
773 OpenMidEndingEval::updateSub(const NumEffectState &new_state, Move last_move)
774 {
775  assert(last_move.player()==P);
776  const Square opp_king =
777  new_state.kingSquare<PlayerTraits<P>::opponent>();
778  const Square self_king =
779  new_state.kingSquare<P>();
780  Ptype captured = last_move.capturePtype();
781  if (captured != PTYPE_EMPTY)
782  {
783  Ptype base = unpromote(captured);
784  if (base == PAWN)
785  {
786  if (P == BLACK)
787  ++black_pawn_count;
788  else
789  --black_pawn_count;
790  }
791  else
792  {
793  ++non_pawn_stand_count[P];
794  }
795  if (captured == PAWN)
796  {
797  pawns[alt(P)][last_move.to().x() - 1] = 0;
798  }
799  if (isMajorBasic(base))
800  {
801  if (P == BLACK)
802  ++black_major_count;
803  else
804  --black_major_count;
805  }
806  if (base == GOLD)
807  {
808  if (P == BLACK)
809  ++black_gold_count;
810  else
811  --black_gold_count;
812  }
813  if (base == GOLD || base == SILVER)
814  {
815  const int y_diff = std::abs(last_move.to().y() - opp_king.y());
816  const int x_diff = std::abs(last_move.to().x() - opp_king.x());
817  if (y_diff <= 2 && x_diff <= 3)
818  {
819  --gs_near_king_count[alt(P)][std::max(x_diff, y_diff) - 1];
820  }
821  }
822  }
823  const Ptype base_ptype = unpromote(last_move.ptype());
824  {
825  if (base_ptype == GOLD || base_ptype == SILVER)
826  {
827  if (!last_move.isDrop())
828  {
829  const int y_diff = std::abs(last_move.from().y() - self_king.y());
830  const int x_diff = std::abs(last_move.from().x() - self_king.x());
831  if (y_diff <= 2 && x_diff <= 3)
832  {
833  --gs_near_king_count[P][std::max(x_diff, y_diff) - 1];
834  }
835  }
836  {
837  const int y_diff = std::abs(last_move.to().y() - self_king.y());
838  const int x_diff = std::abs(last_move.to().x() - self_king.x());
839  if (y_diff <= 2 && x_diff <= 3)
840  {
841  ++gs_near_king_count[P][std::max(x_diff, y_diff) - 1];
842  }
843  }
844  }
845  if (base_ptype == KING)
846  {
847  updateGoldSilverNearKing(new_state);
848  }
849  }
850  if (last_move.isDrop() && last_move.ptype() != PAWN)
851  {
852  --non_pawn_stand_count[P];
853  }
854  if (last_move.ptype() == PPAWN && last_move.isPromotion())
855  {
856  pawns[P][last_move.from().x() - 1] = 0;
857  }
858  if (last_move.ptype() == PAWN)
859  {
860  pawns[P][last_move.to().x() - 1] = last_move.to().y();
861  }
862  const Square kb = new_state.kingSquare<BLACK>(), kw = new_state.kingSquare<WHITE>();
863  {
864  BoardMask mask = new_state.changedEffects();
865  mask.set(last_move.from());
866  mask.set(last_move.to());
867  const bool update_black = mask.anyInRange(Board_Mask_Table5x5.mask(kw)); // black attack to white
868  const bool update_white = mask.anyInRange(Board_Mask_Table5x5.mask(kb));
869  if (update_black ||
870  (effect25_supported[WHITE] & new_state.effectedMask(BLACK)) !=
871  effect25_supported[WHITE] ||
872  (~effect25_supported[WHITE] & effect25[WHITE] & ~new_state.effectedMask(BLACK)) !=
873  (~effect25_supported[WHITE] & effect25[WHITE])){
874  King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
875  new_state, effect25[WHITE], effect25_supported[WHITE],
876  black_attack_effect, black_attack_piece,
877  white_defense_effect, white_defense_piece,
878  black_attack_supported_piece, white_vertical, white_king_vertical);
879  king25_both_side[WHITE]=King25BothSide::evalOne<WHITE>(new_state,white_vertical);
880  }
881  if (update_white ||
882  (effect25_supported[BLACK] & new_state.effectedMask(WHITE)) !=
883  effect25_supported[BLACK] ||
884  (~effect25_supported[BLACK] & effect25[BLACK] & ~new_state.effectedMask(WHITE)) !=
885  (~effect25_supported[BLACK] & effect25[BLACK])){
886  King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
887  new_state, effect25[BLACK], effect25_supported[BLACK],
888  white_attack_effect, white_attack_piece,
889  black_defense_effect, black_defense_piece,
890  white_attack_supported_piece, black_vertical, black_king_vertical);
891  king25_both_side[BLACK]=King25BothSide::evalOne<BLACK>(new_state,black_vertical);
892  }
893  }
894 #ifdef USE_TEST_PROGRESS
895  progress.updateSub<P>(new_state, last_move);
896 #else
897  progress.update(new_state, last_move);
898 #endif
899 
900  progress_independent_value =
901  PieceEval::evalWithUpdate<P>(new_state, last_move, progress_independent_value);
902  piece_stand_value =
903  PieceStand::evalWithUpdate<P>(new_state, last_move,
904  piece_stand_value);
905  if (new_state.longEffectChanged<ROOK>() || last_move.ptype() == KING)
906  {
907  RookMobilityAll::eval(new_state, rook_mobility);
908  rook_effect = RookEffectBase::eval(new_state);
909  }
910  if (new_state.longEffectChanged<BISHOP>())
911  {
912  BishopMobilityAll::eval(new_state, bishop_mobility);
913  bishop_effect = BishopEffectBase::eval(new_state);
914  }
915  else if (last_move.ptype() == KING)
916  {
917  bishop_effect = BishopEffectBase::eval(new_state);
918  }
919  if (new_state.longEffectChanged<LANCE>() || last_move.ptype() == KING)
920  {
921  LanceMobilityAll::eval(new_state, lance_mobility);
922  lance_effect_piece = LanceEffectPieceKingRelative::eval(new_state);
923  }
924 
925  if (new_state.anyEffectChanged<KNIGHT>()) {
926  knight_advance = KnightAdvance::eval(new_state);
927  }
928  KingXBlockedBoth::evalWithUpdateBang(new_state, last_move, kingx_blocked);
929  const MultiInt silver_features = SilverFeatures::eval(new_state);
930  const MultiInt gold_retreat = GoldFeatures::eval(new_state);
931  recalculated_stage_value = silver_features+gold_retreat;
932  recalculated_stage_value += AllGold::eval(black_gold_count);
933  recalculated_stage_value += AllMajor::eval(black_major_count);
934 
935  King25EffectEachBoth::evalWithUpdate(new_state, last_move,
936  king25_effect_each);
937 
938  recalculated_value =
939  BishopExchangeSilverKing::eval(new_state) +
940  EnterKingDefense::eval(new_state) +
941  King25EffectAttack::eval(new_state,
942  black_attack_effect,
943  black_attack_piece,
944  white_attack_effect, white_attack_piece);
945  recalculated_value +=
946  King25EffectYAttack::eval(new_state,
947  black_attack_effect,
948  black_attack_piece,
949  white_attack_effect, white_attack_piece);
950 
951  recalculated_stage_value +=
952  King25EffectDefense::eval(new_state,black_defense_effect,black_defense_piece,
953  white_defense_effect, white_defense_piece);
954  recalculated_stage_value +=
955  King25EffectYDefense::eval(new_state,
956  black_defense_effect,
957  black_defense_piece,
958  white_defense_effect, white_defense_piece);
959  recalculated_stage_value += knight_advance;
960  recalculated_stage_value += AnagumaEmpty::eval(new_state);
961  recalculated_stage_value += kingx_blocked[BLACK] + kingx_blocked[WHITE];
962  recalculated_stage_value += NoPawnOnStand::eval(new_state, black_pawn_count);
963  recalculated_stage_value += NonPawnPieceStand::eval(non_pawn_stand_count[BLACK], non_pawn_stand_count[WHITE]);
964  recalculated_stage_value += PinPtypeAll::eval(new_state);
965  recalculated_stage_value += KingMobility::eval(new_state) + KingMobilitySum::eval(new_state);
966  recalculated_stage_value += GoldAndSilverNearKing::eval(new_state,
967  gs_near_king_count);
968  recalculated_stage_value += PieceStandCombinationBoth::eval(new_state);
969 
970  {
971  MultiInt result_supported =
972  King25EffectSupported::eval(black_attack_piece,
973  white_attack_piece,
974  black_attack_supported_piece,
975  white_attack_supported_piece);
976  MultiInt result_supported_y =
977  King25EffectSupportedY::eval(black_attack_piece,
978  white_attack_piece,
979  black_attack_supported_piece,
980  white_attack_supported_piece,
981  new_state.kingSquare<BLACK>().y(),
982  new_state.kingSquare<WHITE>().y());
983  recalculated_stage_value += result_supported + result_supported_y;
984  if(isMajorNonPieceOK(last_move.ptype()) ||
985  isMajorNonPieceOK(last_move.capturePtype())){ // rook or bishop
986  king_rook_bishop[BLACK]=KingRookBishop::evalOne<BLACK>(new_state);
987  king_rook_bishop[WHITE]=KingRookBishop::evalOne<WHITE>(new_state);
988  }
989  else if(last_move.ptype() == KING){
990  king_rook_bishop[P]=KingRookBishop::evalOne<P>(new_state);
991  }
992  recalculated_stage_value +=king_rook_bishop[BLACK]-king_rook_bishop[WHITE];
993  recalculated_stage_value += KingXBlocked3::eval(new_state);
994  recalculated_stage_value += king25_both_side[BLACK]-king25_both_side[WHITE];
995  recalculated_stage_value += King25Mobility::eval(new_state,
996  black_king_vertical,
997  white_king_vertical);
998  }
999  king_table_value = KingPieceRelative::evalWithUpdate<P>
1000  (new_state, last_move, king_table_value);
1001  piece_pair_value = PiecePair::evalWithUpdateCompiled(new_state,
1002  last_move,
1003  piece_pair_value);
1004  PiecePairKing::evalWithUpdateBang<P>(new_state, last_move,
1005  piece_pair_king_value);
1006  pawn_drop = PawnDropBoth::evalWithUpdate<P>(new_state,
1007  last_move, pawn_drop);
1008 
1009  ptypex = PtypeX::evalWithUpdate<P>(new_state, last_move, ptypex);
1010  ptypey = PtypeY::evalWithUpdate<P>(new_state, last_move, ptypey);
1011  CArray<bool, 2> can_check_new;
1012  can_check_new[BLACK] =
1013  CanCheckNonPawnPieceStandCombination::canCheck<BLACK>(new_state);
1014  can_check_new[WHITE] =
1015  CanCheckNonPawnPieceStandCombination::canCheck<WHITE>(new_state);
1016  piece_stand_combination =
1018  last_move,
1019  piece_stand_combination,
1020  can_check,
1021  can_check_new);
1022  can_check = can_check_new;
1023  NonPawnPieceStandTurn::evalWithUpdateBang<P>(new_state,
1024  last_move,
1025  piece_stand_turn);
1026  rook_pawn = RookPawnY::eval(new_state, pawns);
1027  piece_stand_y = PieceStandY::evalWithUpdate<P>(new_state, last_move,
1028  piece_stand_y);
1029  PawnAdvanceAll::evalWithUpdateBang<P>(new_state,
1030  last_move,
1031  pawn_advance);
1032 
1033  knight_check = KnightCheck::eval(new_state);
1034  pawn_ptypeo = PawnPtypeOPtypeO::template evalWithUpdate<P>(new_state, last_move,
1035  pawns,
1036  pawn_ptypeo);
1037 
1038  promoted_minor_piece =
1040  last_move,
1041  promoted_minor_piece);
1042 
1043  nosupport = KingPieceRelativeNoSupport::evalWithUpdate(new_state, last_move,
1044  effected_mask,
1045  nosupport);
1046  NonPawnAttacked::evalWithUpdateBang<P>(new_state,
1047  last_move,
1048  effected_mask_for_attacked,
1049  non_pawn_attacked);
1050  NonPawnAttackedPtype::evalWithUpdateBang<P>(
1051  new_state, last_move, effected_mask_for_attacked,
1052  attacked_mask, non_pawn_attacked_ptype);
1053  effected_mask[BLACK] =
1054  effected_mask_for_attacked[BLACK] =
1055  new_state.effectedMask(BLACK);
1056  effected_mask[WHITE] =
1057  effected_mask_for_attacked[WHITE] =
1058  new_state.effectedMask(WHITE);
1059  mask_t black_ppawn =
1060  effected_mask_for_attacked[BLACK].selectBit<PAWN>() &
1061  new_state.promotedPieces().template getMask<PAWN>();
1062  mask_t white_ppawn =
1063  effected_mask_for_attacked[WHITE].selectBit<PAWN>() &
1064  new_state.promotedPieces().template getMask<PAWN>();
1065  effected_mask_for_attacked[BLACK].clearBit<PAWN>();
1066  effected_mask_for_attacked[WHITE].clearBit<PAWN>();
1067  effected_mask_for_attacked[BLACK].orMask(PtypeFuns<PAWN>::indexNum, black_ppawn);
1068  effected_mask_for_attacked[WHITE].orMask(PtypeFuns<PAWN>::indexNum, white_ppawn);
1069 
1070  ptype_yy = PtypeYY::evalWithUpdate(new_state, last_move, ptype_yy);
1071  king3pieces = King3Pieces::evalWithUpdate(new_state, last_move, king3pieces);
1072  bishop_head = BishopHead::eval(new_state);
1073  knight_head = KnightHead::eval(new_state);
1074  rook_promote_defense = RookPromoteDefense::eval(new_state);
1075  PtypeCount::evalWithUpdateBang<P>(new_state,
1076  last_move, ptype_count, ptype_board_count,
1077  ptype_count_value,ptypeo_mask);
1078  PtypeYPawnY::evalWithUpdateBang<P>(new_state, last_move,pawns, ptype_y_pawn_y);
1079  recalculated_stage_value += PtypeCombination::eval(ptypeo_mask);
1080  bishop_and_king = NumPiecesBetweenBishopAndKing::eval(new_state);
1081  recalculated_stage_value += King25Effect3::eval(new_state, effect25);
1082  recalculated_stage_value += BishopBishopPiece::eval(new_state);
1083  recalculated_stage_value += RookRook::eval(new_state);
1084  recalculated_stage_value += RookRookPiece::eval(new_state);
1085  recalculated_stage_value += King25EffectCountCombination::eval(new_state, effect25);
1086  recalculated_stage_value += BishopStandFile5::eval(new_state);
1087  recalculated_stage_value += MajorCheckWithCapture::eval(new_state);
1088  recalculated_stage_value += SilverAdvance26::eval(new_state);
1089  if (base_ptype == ROOK || last_move.ptype() == SILVER ||
1090  last_move.ptype() == KNIGHT ||
1091  captured == ROOK || captured == PROOK || captured == SILVER ||
1092  captured == KNIGHT ||
1093  (last_move.isPromotion() &&
1094  (base_ptype == SILVER || base_ptype == KNIGHT)))
1095  {
1096  rook_silver_knight = RookSilverKnight::eval(new_state);
1097  }
1098  if (base_ptype == BISHOP || last_move.ptype() == SILVER ||
1099  last_move.ptype() == KNIGHT ||
1100  captured == BISHOP || captured == PBISHOP || captured == SILVER ||
1101  captured == KNIGHT ||
1102  (last_move.isPromotion() &&
1103  (base_ptype == SILVER || base_ptype == KNIGHT)))
1104  {
1105  bishop_silver_knight = BishopSilverKnight::eval(new_state);
1106  }
1107  recalculated_stage_value += AttackMajorsInBase::eval(new_state);
1108  recalculated_stage_value += CheckShadowPtype::eval(new_state);
1109 #ifdef USE_TEST_PROGRESS
1110  recalculated_stage_value += progress.rawData().promotion37_eval;
1111  recalculated_stage_value += progress.rawData().non_pawn_ptype_attacked_pair_eval[BLACK]
1112  + progress.rawData().non_pawn_ptype_attacked_pair_eval[WHITE];
1113 #else
1114  recalculated_stage_value += Promotion37::eval(new_state);
1115  recalculated_stage_value += NonPawnAttackedPtypePair::eval(new_state);
1116 #endif
1117  piece_fork_turn = SilverFork::eval(new_state, silver_drop);
1118  piece_fork_turn += BishopRookFork::eval(new_state, bishop_drop, rook_drop);
1119  piece_fork_turn += KnightFork::evalWithUpdate<P>(new_state, last_move, knight_fork_squares, knight_drop);
1120  invalidateCache();
1121 }
1122 
1123 #ifndef MINIMAL
1126 {
1127  OpenMidEndingEvalDebugInfo debug_info;
1128  debug_info.value = value();
1129  debug_info.progress = progress16().value();
1130  debug_info.progress_independent_values[OpenMidEndingEvalDebugInfo::PIECE] = progress_independent_value;
1134  = EnterKingDefense::eval(state);
1135  int black_attack_effect, black_attack_piece, black_defense_effect, black_defense_piece,
1136  white_attack_effect, white_attack_piece, white_defense_effect, white_defense_piece;
1137  CArray<int, 5> black_vertical, white_vertical,
1138  black_king_vertical, white_king_vertical;
1139  King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[WHITE],
1140  effect25_supported[WHITE],
1141  black_attack_effect, black_attack_piece,
1142  white_defense_effect, white_defense_piece,
1143  black_attack_supported_piece,
1144  white_vertical,
1145  white_king_vertical);
1146  King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[BLACK],
1147  effect25_supported[BLACK],
1148  white_attack_effect, white_attack_piece,
1149  black_defense_effect, black_defense_piece,
1150  white_attack_supported_piece,
1151  black_vertical,
1152  black_king_vertical);
1154  King25EffectBoth::eval(state,
1155  black_attack_effect,
1156  black_attack_piece,
1157  white_attack_effect, white_attack_piece,
1158  black_defense_effect, black_defense_piece,
1159  white_defense_effect, white_defense_piece) +
1160  King25EffectY::eval(state,
1161  black_attack_effect,
1162  black_attack_piece,
1163  white_attack_effect, white_attack_piece,
1164  black_defense_effect, black_defense_piece,
1165  white_defense_effect, white_defense_piece);
1167  debug_info.progress_independent_values[OpenMidEndingEvalDebugInfo::PIECE_PAIR_KING] = piece_pair_king_value[BLACK] + piece_pair_king_value[WHITE];
1168 
1170  king_table_value;
1172  piece_stand_value;
1174  king25_effect_each[BLACK] + king25_effect_each[WHITE];
1175  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PTYPEX] = ptypex;
1176  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PTYPEY] = ptypey;
1177  debug_info.stage_values[OpenMidEndingEvalDebugInfo::ROOK_MOBILITY] = rook_mobility;
1178  debug_info.stage_values[OpenMidEndingEvalDebugInfo::BISHOP_MOBILITY] = bishop_mobility;
1179  debug_info.stage_values[OpenMidEndingEvalDebugInfo::LANCE_MOBILITY] = lance_mobility;
1180  debug_info.stage_values[OpenMidEndingEvalDebugInfo::ROOK_EFFECT] = rook_effect;
1181  debug_info.stage_values[OpenMidEndingEvalDebugInfo::BISHOP_EFFECT] = bishop_effect;
1182  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PIECE_STAND_COMBINATION] = piece_stand_combination;
1183  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PIECE_STAND_TURN] = piece_stand_turn[turn];
1184  debug_info.stage_values[OpenMidEndingEvalDebugInfo::ROOK_PAWN] = rook_pawn;
1185  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PAWN_DROP] = pawn_drop;
1186  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PIECE_STAND_Y] = piece_stand_y;
1187  debug_info.stage_values[OpenMidEndingEvalDebugInfo::KNIGHT_CHECK] = knight_check;
1188  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PAWN_ADVANCE] = pawn_advance;
1189  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PAWN_PTYPEO] = pawn_ptypeo;
1190  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PROMOTED_MINOR_PIECE] = promoted_minor_piece;
1192  debug_info.stage_values[OpenMidEndingEvalDebugInfo::NON_PAWN_ATTACKED] = non_pawn_attacked[turn];
1193  debug_info.stage_values[OpenMidEndingEvalDebugInfo::NON_PAWN_ATTACKED_PTYPE] = non_pawn_attacked_ptype[turn];
1194  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PTYPE_YY] = ptype_yy;
1195  debug_info.stage_values[OpenMidEndingEvalDebugInfo::KING3PIECES] = king3pieces;
1196  debug_info.stage_values[OpenMidEndingEvalDebugInfo::BISHOP_HEAD] = bishop_head;
1197  debug_info.stage_values[OpenMidEndingEvalDebugInfo::KNIGHT_HEAD] = knight_head;
1198  debug_info.stage_values[OpenMidEndingEvalDebugInfo::ROOK_PROMOTE_DEFENSE] = rook_promote_defense;
1199  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PTYPE_COUNT] = ptype_count_value;
1200  debug_info.stage_values[OpenMidEndingEvalDebugInfo::LANCE_EFFECT_PIECE] = lance_effect_piece;
1201  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PTYPE_Y_PAWN_Y] = ptype_y_pawn_y;
1202  debug_info.stage_values[OpenMidEndingEvalDebugInfo::BISHOP_AND_KING] = bishop_and_king;
1203  debug_info.stage_values[OpenMidEndingEvalDebugInfo::PIECE_FORK_TURN] = piece_fork_turn[turn];
1204  debug_info.stage_values[OpenMidEndingEvalDebugInfo::ROOK_SILVER_KNIGHT] = rook_silver_knight;
1205  debug_info.stage_values[OpenMidEndingEvalDebugInfo::BISHOP_SILVER_KNIGHT] = bishop_silver_knight;
1207  King25EffectSupported::eval(black_attack_piece,
1208  white_attack_piece,
1209  black_attack_supported_piece,
1210  white_attack_supported_piece) +
1211  King25EffectSupportedY::eval(black_attack_piece,
1212  white_attack_piece,
1213  black_attack_supported_piece,
1214  white_attack_supported_piece,
1215  state.kingSquare<BLACK>().y(),
1216  state.kingSquare<WHITE>().y());
1218  king_rook_bishop[BLACK] - king_rook_bishop[WHITE];
1220  KingXBlocked3::eval(state);
1222  GoldFeatures::eval(state);
1224  SilverFeatures::eval(state);
1226  AllGold::eval(black_gold_count);
1228  AllMajor::eval(black_major_count);
1230  King25EffectDefense::eval(state, black_defense_effect, black_defense_piece,
1231  white_defense_effect, white_defense_piece) +
1233  black_defense_effect,
1234  black_defense_piece,
1235  white_defense_effect, white_defense_piece);
1237  AnagumaEmpty::eval(state);
1239  NoPawnOnStand::eval(state, black_pawn_count);
1241  NonPawnPieceStand::eval(non_pawn_stand_count[BLACK], non_pawn_stand_count[WHITE]);
1243  PinPtypeAll::eval(state);
1245  KingMobility::eval(state) + KingMobilitySum::eval(state);
1248  gs_near_king_count);
1250  PtypeCombination::eval(ptypeo_mask);
1252  king25_both_side[BLACK] - king25_both_side[WHITE];
1254  King25Mobility::eval(state,
1255  black_king_vertical,
1256  white_king_vertical);
1258  BishopStandFile5::eval(state);
1262  SilverAdvance26::eval(state);
1264  King25Effect3::eval(state, effect25);
1266  BishopBishopPiece::eval(state);
1268  RookRook::eval(state);
1270  RookRookPiece::eval(state);
1272  King25EffectCountCombination::eval(state, effect25);
1276  AttackMajorsInBase::eval(state);
1277 
1278  return debug_info;
1279 }
1280 
1281 #define DEBUGPRINT(x) std::cerr << " " << #x << " " << x << "\n"
1283 debug() const
1284 {
1285  DEBUGPRINT(king_table_value[0]);
1286  DEBUGPRINT(piece_stand_value[0]);
1287  DEBUGPRINT(king25_effect_each[BLACK][0] + king25_effect_each[WHITE][0]);
1288  DEBUGPRINT(ptypex[0]);
1289  DEBUGPRINT(ptypey[0]);
1290  DEBUGPRINT(rook_mobility[0]);
1291  DEBUGPRINT(bishop_mobility[0]);
1292  DEBUGPRINT(lance_mobility[0]);
1293  DEBUGPRINT(rook_effect[0]);
1294  DEBUGPRINT(bishop_effect[0]);
1295  DEBUGPRINT(piece_stand_combination[0]);
1296  DEBUGPRINT(piece_stand_turn[turn][0]);
1297  DEBUGPRINT(rook_pawn[0]);
1298  DEBUGPRINT(pawn_drop[0]);
1299  DEBUGPRINT(piece_stand_y[0]);
1300  DEBUGPRINT(knight_check[0]);
1301  DEBUGPRINT(pawn_advance[0]);
1302  DEBUGPRINT(pawn_ptypeo[0]);
1303  DEBUGPRINT(promoted_minor_piece[0]);
1304  DEBUGPRINT(nosupport[0]);
1305  DEBUGPRINT(non_pawn_attacked[turn][0]);
1306  DEBUGPRINT(non_pawn_attacked_ptype[turn][0]);
1307  DEBUGPRINT(ptype_yy[0]);
1308  DEBUGPRINT(king3pieces[0]);
1309  DEBUGPRINT(bishop_head[0]);
1310  DEBUGPRINT(knight_head[0]);
1311  DEBUGPRINT(rook_promote_defense[0]);
1312  DEBUGPRINT(ptype_count_value[0]);
1313  DEBUGPRINT(lance_effect_piece[0]);
1314  DEBUGPRINT(ptype_y_pawn_y[0]);
1315  DEBUGPRINT(bishop_and_king[0]);
1316  DEBUGPRINT(recalculated_stage_value[0]);
1317 }
1318 
1321 {
1322  boost::mutex::scoped_lock lk(initialize_mutex);
1323  initialized_flag = Random;
1324 
1325  setRandomOne<King25EffectAttack>();
1326  setRandomOne<King25EffectYAttack>();
1327 
1328  // opening
1329  setRandomOne<PieceStand>(0);
1330  setRandomOne<Pin>(0);
1331  setRandomOne<King25EffectEachBothOpening>();
1332  setRandomOne<PawnDrop>(0);
1333  setRandomOne<NoPawnOnStand>(0);
1334  setRandomOne<GoldRetreat>(0);
1335  setRandomOne<SilverRetreat>(0);
1336  setRandomOne<KnightAdvance>(0);
1337  setRandomOne<AllMajor>(0);
1338  setRandomOne<KingXBlocked>(0);
1339  setRandomOne<KingXBlockedY>(0);
1340  setRandomOne<AllGold>(0);
1341  setRandomOne<PtypeX>(0);
1342  setRandomOne<PtypeY>(0);
1343  setRandomOne<AnagumaEmpty>(0);
1344  setRandomOne<NonPawnPieceStand>(0);
1345  setRandomOne<King25EffectDefense>(0);
1346  setRandomOne<King25EffectYDefense>(0);
1347  setRandomOne<RookMobility>(0);
1348  setRandomOne<BishopMobility>(0);
1349  setRandomOne<LanceMobility>(0);
1350  setRandomOne<RookEffect>(0);
1351  setRandomOne<BishopEffect>(0);
1352  setRandomOne<PawnAdvance>(0);
1353  setRandomOne<PawnDropY>(0);
1354  setRandomOne<KnightCheck>(0);
1355 
1356  // midgame
1357  setRandomOne<PieceStand>(1);
1358  setRandomOne<Pin>(1);
1359  setRandomOne<King25EffectEachBothMidgame>();
1360  setRandomOne<PawnDrop>(1);
1361  setRandomOne<NoPawnOnStand>(1);
1362  setRandomOne<GoldRetreat>(1);
1363  setRandomOne<SilverRetreat>(1);
1364  setRandomOne<KnightAdvance>(1);
1365  setRandomOne<AllMajor>(1);
1366  setRandomOne<KingXBlocked>(1);
1367  setRandomOne<KingXBlockedY>(1);
1368  setRandomOne<AllGold>(1);
1369  setRandomOne<PtypeX>(1);
1370  setRandomOne<PtypeY>(1);
1371  setRandomOne<AnagumaEmpty>(1);
1372  setRandomOne<NonPawnPieceStand>(1);
1373  setRandomOne<King25EffectDefense>(1);
1374  setRandomOne<King25EffectYDefense>(1);
1375  setRandomOne<RookMobility>(1);
1376  setRandomOne<BishopMobility>(1);
1377  setRandomOne<LanceMobility>(1);
1378  setRandomOne<RookEffect>(1);
1379  setRandomOne<BishopEffect>(1);
1380  setRandomOne<PawnAdvance>(1);
1381  setRandomOne<PawnDropY>(1);
1382  setRandomOne<KnightCheck>(1);
1383 
1384 #ifdef EVAL_QUAD
1385  // midgame2
1386  setRandomOne<PieceStand>(2);
1387  setRandomOne<Pin>(2);
1388  setRandomOne<King25EffectEachBothEnding>();
1389  setRandomOne<PawnDrop>(2);
1390  setRandomOne<NoPawnOnStand>(2);
1391  setRandomOne<GoldRetreat>(2);
1392  setRandomOne<SilverRetreat>(2);
1393  setRandomOne<KnightAdvance>(2);
1394  setRandomOne<AllMajor>(2);
1395  setRandomOne<KingXBlocked>(2);
1396  setRandomOne<KingXBlockedY>(2);
1397  setRandomOne<AllGold>(2);
1398  setRandomOne<PtypeX>(2);
1399  setRandomOne<PtypeY>(2);
1400  setRandomOne<AnagumaEmpty>(2);
1401  setRandomOne<NonPawnPieceStand>(2);
1402  setRandomOne<King25EffectDefense>(2);
1403  setRandomOne<King25EffectYDefense>(2);
1404  setRandomOne<RookMobility>(2);
1405  setRandomOne<BishopMobility>(2);
1406  setRandomOne<LanceMobility>(2);
1407  setRandomOne<RookEffect>(2);
1408  setRandomOne<BishopEffect>(2);
1409  setRandomOne<PawnAdvance>(2);
1410  setRandomOne<PawnDropY>(2);
1411  setRandomOne<KnightCheck>(2);
1412 #endif
1413  // endgame
1414  setRandomOne<PieceStand>(EndgameIndex);
1415  setRandomOne<Pin>(EndgameIndex);
1416  setRandomOne<King25EffectEachBothMidgame>();
1417  setRandomOne<PawnDrop>(EndgameIndex);
1418  setRandomOne<NoPawnOnStand>(EndgameIndex);
1419  setRandomOne<GoldRetreat>(EndgameIndex);
1420  setRandomOne<SilverRetreat>(EndgameIndex);
1421  setRandomOne<KnightAdvance>(EndgameIndex);
1422  setRandomOne<AllMajor>(EndgameIndex);
1423  setRandomOne<KingXBlocked>(EndgameIndex);
1424  setRandomOne<KingXBlockedY>(EndgameIndex);
1425  setRandomOne<AllGold>(EndgameIndex);
1426  setRandomOne<PtypeX>(EndgameIndex);
1427  setRandomOne<PtypeY>(EndgameIndex);
1428  setRandomOne<AnagumaEmpty>(EndgameIndex);
1429  setRandomOne<NonPawnPieceStand>(EndgameIndex);
1430  setRandomOne<King25EffectDefense>(EndgameIndex);
1431  setRandomOne<King25EffectYDefense>(EndgameIndex);
1432  setRandomOne<RookMobility>(EndgameIndex);
1433  setRandomOne<BishopMobility>(EndgameIndex);
1434  setRandomOne<LanceMobility>(EndgameIndex);
1435  setRandomOne<RookEffect>(EndgameIndex);
1436  setRandomOne<BishopEffect>(EndgameIndex);
1437  setRandomOne<PawnAdvance>(EndgameIndex);
1438  setRandomOne<PawnDropY>(EndgameIndex);
1439  setRandomOne<KnightCheck>(EndgameIndex);
1440 
1441  // both
1442  setRandomOne<KingPieceRelative>(0);
1443  setRandomOne<KingPieceRelative>(1);
1444 #ifdef EVAL_QUAD
1445  setRandomOne<KingPieceRelative>(2);
1446 #endif
1447  setRandomOne<KingPieceRelative>(EndgameIndex);
1448  setRandomOne<NonPawnPieceStandCombination>();
1449  setRandomOne<NonPawnPieceStandTurn>();
1450  setRandomOne<King25EffectEachXY>();
1451  setRandomOne<RookPawnY>();
1452  setRandomOne<RookEffectPiece>();
1453  setRandomOne<BishopEffectPiece>();
1454  setRandomOne<PieceStandY>();
1455  setRandomOne<RookEffectPieceKingRelative>();
1456  setRandomOne<BishopEffectPieceKingRelative>();
1457  setRandomOne<RookPawnYX>();
1458  setRandomOne<PawnPtypeOPtypeO>();
1459  setRandomOne<CanCheckNonPawnPieceStandCombination>();
1460  setRandomOne<PromotedMinorPieces>();
1461  setRandomOne<KingPieceRelativeNoSupport>();
1462  setRandomOne<NonPawnAttacked>();
1463  setRandomOne<PtypeYY>();
1464  setRandomOne<PawnPtypeOPtypeOY>();
1465  setRandomOne<PawnDropX>();
1466  setRandomOne<King3Pieces>();
1467  setRandomOne<King3PiecesXY>();
1468  setRandomOne<King25EffectEachKXY>();
1469  setRandomOne<BishopHead>();
1470  setRandomOne<BishopHeadKingRelative>();
1471  setRandomOne<KnightCheckY>();
1472  setRandomOne<KnightHead>();
1473  setRandomOne<RookPromoteDefense>();
1474  setRandomOne<PawnDropPawnStand>();
1475  setRandomOne<PawnDropPawnStandX>();
1476  setRandomOne<PawnDropPawnStandY>();
1477  setRandomOne<King25Effect2>();
1478  setRandomOne<King25EffectY2>();
1479  setRandomOne<KnightHeadOppPiecePawnOnStand>();
1480  setRandomOne<KingXBothBlocked>();
1481  setRandomOne<KingXBothBlockedY>();
1482  setRandomOne<KingRookBishop>();
1483  setRandomOne<PromotedMinorPiecesY>();
1484  setRandomOne<King25EffectSupported>();
1485  setRandomOne<King25EffectSupportedY>();
1486  setRandomOne<NonPawnAttackedKingRelative>();
1487  setRandomOne<NonPawnAttackedPtype>();
1488  setRandomOne<PtypeCount>();
1489  setRandomOne<KingXBlocked3>();
1490  setRandomOne<KingXBlocked3Y>();
1491  setRandomOne<PtypeCountXY>();
1492  setRandomOne<PtypeCountXYAttack>();
1493  setRandomOne<LanceEffectPieceKingRelative>();
1494  setRandomOne<KingMobility>();
1495  setRandomOne<KingMobilitySum>();
1496  setRandomOne<MajorCheckWithCapture>();
1497  setRandomOne<RookSilverKnight>();
1498  setRandomOne<BishopSilverKnight>();
1499 }
1500 #endif
1501 
1502 #ifndef DFPNSTATONE
1503 namespace osl
1504 {
1505  template void
1506  EffectUtil::findThreat<osl::eval::ml::OpenMidEndingEval>(
1507  const NumEffectState& state,
1508  Square position,
1509  PtypeO ptypeo,
1510  PieceVector& out);
1511 }
1512 #endif
1513 
1514 // ;;; Local Variables:
1515 // ;;; mode:c++
1516 // ;;; c-basic-offset:2
1517 // ;;; End: