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