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 
195 void osl::eval::ml::
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>
220 void osl::eval::ml::
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 
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],
584  effect25_supported[BLACK],
592  EnterKingDefense::eval(state) +
594  black_attack_effect,
595  black_attack_piece,
596  white_attack_effect, white_attack_piece);
597  recalculated_value +=
599  black_attack_effect,
600  black_attack_piece,
601  white_attack_effect, white_attack_piece);
603  {
604  MultiInt result_supported =
605  King25EffectSupported::eval(black_attack_piece,
606  white_attack_piece,
607  black_attack_supported_piece,
608  white_attack_supported_piece);
609  MultiInt result_supported_y =
610  King25EffectSupportedY::eval(black_attack_piece,
611  white_attack_piece,
612  black_attack_supported_piece,
613  white_attack_supported_piece,
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);
620  recalculated_stage_value+=king_rook_bishop[BLACK]-king_rook_bishop[WHITE];
621  recalculated_stage_value+=KingXBlocked3::eval(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;
632  King25EffectDefense::eval(state,black_defense_effect,black_defense_piece,
633  white_defense_effect, white_defense_piece);
636  black_defense_effect,
637  black_defense_piece,
638  white_defense_effect, white_defense_piece);
641 
650  king25_both_side[BLACK]=King25BothSide::evalOne<BLACK>(state,black_vertical);
651  king25_both_side[WHITE]=King25BothSide::evalOne<WHITE>(state,white_vertical);
652  recalculated_stage_value += king25_both_side[BLACK]-king25_both_side[WHITE];
653  recalculated_stage_value += King25Mobility::eval(state,
656  recalculated_stage_value += BishopStandFile5::eval(state);
657  recalculated_stage_value += MajorCheckWithCapture::eval(state);
658  recalculated_stage_value += SilverAdvance26::eval(state);
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);
713  recalculated_stage_value += King25Effect3::eval(state, effect25);
714  recalculated_stage_value += BishopBishopPiece::eval(state);
715  recalculated_stage_value += RookRook::eval(state);
716  recalculated_stage_value += RookRookPiece::eval(state);
717  recalculated_stage_value += King25EffectCountCombination::eval(state, effect25);
718  recalculated_stage_value += NonPawnAttackedPtypePair::eval(state);
721  recalculated_stage_value += AttackMajorsInBase::eval(state);
722  recalculated_stage_value += CheckShadowPtype::eval(state);
723  recalculated_stage_value += Promotion37::eval(state);
727  invalidateCache();
728 }
729 
730 int osl::eval::ml::
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() +
745 #else
746  return roundUp(value * 16 +
747  openingValue() * (16 - progress.progress16().value()) +
749 #endif
750 }
751 
752 void osl::eval::ml::
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>
768 void osl::eval::ml::
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)
784  else
786  }
787  else
788  {
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)
799  else
801  }
802  if (base == GOLD)
803  {
804  if (P == BLACK)
806  else
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  {
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)) !=
868  (~effect25_supported[WHITE] & effect25[WHITE] & ~new_state.effectedMask(BLACK)) !=
870  King25EffectBoth::countEffectAndPiecesBoth<BLACK>(
871  new_state, effect25[WHITE], effect25_supported[WHITE],
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)) !=
880  (~effect25_supported[BLACK] & effect25[BLACK] & ~new_state.effectedMask(WHITE)) !=
882  King25EffectBoth::countEffectAndPiecesBoth<WHITE>(
883  new_state, effect25[BLACK], effect25_supported[BLACK],
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 
897  PieceEval::evalWithUpdate<P>(new_state, last_move, progress_independent_value);
899  PieceStand::evalWithUpdate<P>(new_state, last_move,
901  if (new_state.longEffectChanged<ROOK>() || last_move.ptype() == KING)
902  {
904  rook_effect = RookEffectBase::eval(new_state);
905  }
906  if (new_state.longEffectChanged<BISHOP>())
907  {
910  }
911  else if (last_move.ptype() == KING)
912  {
914  }
915  if (new_state.longEffectChanged<LANCE>() || last_move.ptype() == KING)
916  {
919  }
920 
921  if (new_state.anyEffectChanged<KNIGHT>()) {
922  knight_advance = KnightAdvance::eval(new_state);
923  }
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;
930 
931  King25EffectEachBoth::evalWithUpdate(new_state, last_move,
933 
935  BishopExchangeSilverKing::eval(new_state) +
936  EnterKingDefense::eval(new_state) +
937  King25EffectAttack::eval(new_state,
942  King25EffectYAttack::eval(new_state,
946 
951  King25EffectYDefense::eval(new_state,
965 
966  {
967  MultiInt result_supported =
972  MultiInt result_supported_y =
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,
994  }
995  king_table_value = KingPieceRelative::evalWithUpdate<P>
996  (new_state, last_move, king_table_value);
998  last_move,
999  piece_pair_value);
1000  PiecePairKing::evalWithUpdateBang<P>(new_state, last_move,
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);
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,
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 
1036  last_move,
1037  promoted_minor_piece);
1038 
1040  effected_mask,
1041  nosupport);
1042  NonPawnAttacked::evalWithUpdateBang<P>(new_state,
1043  last_move,
1046  NonPawnAttackedPtype::evalWithUpdateBang<P>(
1047  new_state, last_move, effected_mask_for_attacked,
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);
1071  PtypeCount::evalWithUpdateBang<P>(new_state,
1072  last_move, ptype_count, ptype_board_count,
1074  PtypeYPawnY::evalWithUpdateBang<P>(new_state, last_move,pawns, ptype_y_pawn_y);
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  {
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  {
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]
1109 #else
1110  recalculated_stage_value += Promotion37::eval(new_state);
1111  recalculated_stage_value += NonPawnAttackedPtypePair::eval(new_state);
1112 #endif
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();
1130  = EnterKingDefense::eval(state);
1135  King25EffectBoth::countEffectAndPiecesBoth<BLACK>(state, effect25[WHITE],
1142  King25EffectBoth::countEffectAndPiecesBoth<WHITE>(state, effect25[BLACK],
1143  effect25_supported[BLACK],
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);
1164 
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());
1216  KingXBlocked3::eval(state);
1218  GoldFeatures::eval(state);
1220  SilverFeatures::eval(state);
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);
1239  PinPtypeAll::eval(state);
1241  KingMobility::eval(state) + KingMobilitySum::eval(state);
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 {
1284  DEBUGPRINT(ptypex[0]);
1285  DEBUGPRINT(ptypey[0]);
1289  DEBUGPRINT(rook_effect[0]);
1293  DEBUGPRINT(rook_pawn[0]);
1294  DEBUGPRINT(pawn_drop[0]);
1298  DEBUGPRINT(pawn_ptypeo[0]);
1300  DEBUGPRINT(nosupport[0]);
1301  DEBUGPRINT(non_pawn_attacked[turn][0]);
1303  DEBUGPRINT(ptype_yy[0]);
1304  DEBUGPRINT(king3pieces[0]);
1305  DEBUGPRINT(bishop_head[0]);
1306  DEBUGPRINT(knight_head[0]);
1313 }
1314 
1317 {
1318  std::lock_guard<std::mutex> lk(initialize_mutex);
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:
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:2945
static MultiIntPair eval(const NumEffectState &state, CArray< BoardMask, 2 > &knight_fork_squares, CArray< std::pair< Square, int >, 2 > &knight_drop)
Definition: minorPiece.cc:2737
Ptype unpromote(Ptype ptype)
ptypeがpromote後の型の時に,promote前の型を返す. promoteしていない型の時はそのまま返す ...
Definition: basic_type.h:157
static MultiInt eval(const NumEffectState &state)
static void eval(const NumEffectState &state, MultiIntPair &out)
Definition: minorPiece.cc:1156
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:523
static void eval(const NumEffectState &state, MultiIntPair &out)
IntArrayReader(const int *a, size_t l)
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:483
int max(Player p, int v1, int v2)
Definition: evalTraits.h:84
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:397
bool isOnBoard() const
Definition: basic_type.h:985
GeneralMask< mask_int_t > mask_t
Definition: mask.h:351
CArray< MultiInt, STAGE_FEATURE_LIMIT > stage_values
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, const MultiInt &last_values)
Definition: minorPiece.cc:1084
static void evalWithUpdate(const NumEffectState &state, Move last_move, MultiIntPair &values)
Definition: kingTable.cc:1058
static int eval(const NumEffectState &state)
Definition: ptypeEval.cc:77
const BoardMask changedEffects(Player pl) const
static volatile LoadStatus initialized_flag
static MultiIntPair eval(const NumEffectState &state)
Definition: king8.cc:634
constexpr Player alt(Player player)
Definition: basic_type.h:13
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:692
Ptype ptype() const
Definition: basic_type.h:821
void update(const NumEffectState &new_state, Move last_move)
static int eval(const NumEffectState &state)
Definition: kingTable.cc:2008
CArray2d< int, 2, 3 > gs_near_king_count
static CArray< int, 2 > eval(const NumEffectState &)
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:1386
static MultiInt evalWithUpdate(const NumEffectState &state, Move last_move, MultiInt &last_value)
Definition: kingTable.cc:1319
static MultiIntPair eval(const NumEffectState &state, CArray< std::pair< Square, int >, 2 > &silver_drop)
Definition: minorPiece.cc:2369
int countPiecesOnStand(Player pl, Ptype ptype) const
持駒の枚数を数える
Definition: simpleState.h:182
PtypeO ptypeO() const
Definition: basic_type.h:824
bool isMajorNonPieceOK(Ptype ptype)
Definition: basic_type.h:190
int y() const
将棋としてのY座標を返す.
Definition: basic_type.h:567
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, const MultiInt &last_value, const CArray< bool, 2 > &could_check, const CArray< bool, 2 > &can_check)
static void compile(const Weights &values)
values を展開してクラス全体で使う
Definition: piecePair.cc:365
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1187
static int eval(const NumEffectState &, const Weights &)
Definition: piecePair.cc:450
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
const int PTYPE_SIZE
Definition: basic_type.h:107
static void resetWeights(const int *w, size_t length)
static MultiInt eval(int black_major_count)
Definition: minorPiece.h:719
static int eval(const NumEffectState &state, int black_effect, int black_piece, int white_effect, int white_piece)
Definition: kingTable.h:246
int x() const
将棋としてのX座標を返す.
Definition: basic_type.h:563
static MultiInt eval(const NumEffectState &state, const CArray2d< int, 2, 9 > &pawns)
Definition: minorPiece.cc:2046
void setValue(size_t index, int value)
Definition: weights.h:31
static MultiInt eval(const NumEffectState &state)
Definition: eval_pin.cc:186
static MultiInt eval(const NumEffectState &state, const CArray< bool, 2 > &can_check)
Ptype
駒の種類を4ビットでコード化する
Definition: basic_type.h:83
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1483
static MultiInt eval(const NumEffectState &state, const CArray< PieceMask, 2 > &king25)
Definition: kingTable.cc:1901
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1062
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:3025
const Piece pieceOf(int num) const
Definition: simpleState.h:76
Square kingSquare() const
Definition: simpleState.h:94
Ptype ptype() const
Definition: basic_type.h:1155
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:1069
static MultiInt eval(const NumEffectState &state)
Definition: kingTable.cc:331
static void doResetWeights(Reader &reader)
static MultiInt eval(const NumEffectState &state)
static int eval(const NumEffectState &, int black_effect, int black_piece, int white_effect, int white_piece)
Definition: kingTable.h:193
static void eval(const NumEffectState &state, CArray< PieceMask, 40 > &attacked_mask, MultiIntPair &out)
Definition: minorPiece.cc:1452
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
const Square from() const
Definition: basic_type.h:1125
static MultiInt eval(const NumEffectState &state)
Definition: kingTable.cc:1586
static const MultiIntPair eval(const NumEffectState &state)
const int EndgameIndex
Definition: midgame.h:16
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1269
static void evalWithUpdateBang(const NumEffectState &new_state, Move last_move, MultiIntPair &last_values_and_out)
Definition: king8.cc:916
圧縮していない moveの表現 .
Definition: basic_type.h:1051
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1104
static void eval(const NumEffectState &, MultiInt &out)
Definition: mobility.cc:145
void updateSub(const NumEffectState &new_state, Move last_move)
Definition: progress.cc:684
static const int SIZE
Definition: basic_type.h:794
bool isPass() const
Definition: basic_type.h:1092
void update(const NumEffectState &new_state, Move last_move)
Definition: progress.h:246
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:312
bool isPromoted() const
promoteした駒かどうかをチェックする
Definition: basic_type.h:898
#define DEBUGPRINT(x)
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
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:254
CArray< PieceMask, 2 > effected_mask_for_attacked
CArray< BoardMask, 2 > knight_fork_squares
static MultiInt eval(const NumEffectState &state)
Definition: eval_pin.cc:248
static MultiInt eval(int black_major_count)
Definition: majorPiece.h:121
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1353
static MultiInt eval(unsigned int ptypeo_mask)
Definition: minorPiece.cc:2293
Player player() const
Definition: basic_type.h:1195
static MultiInt eval(const NumEffectState &state, const CArray< PieceMask, 2 > &king25_mask)
Definition: kingTable.cc:1767
CArray2d< int, 2, PTYPE_SIZE > ptype_count
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, const CArray< PieceMask, 2 > &effected_mask, const MultiInt &last_values)
Definition: kingTable.cc:179
Player turn() const
Definition: simpleState.h:220
static MultiInt eval(const NumEffectState &state)
Definition: kingTable.cc:146
static std::mutex initialize_mutex
static MultiInt eval(const NumEffectState &state)
Definition: kingTable.cc:1534
CArray< PieceMask, 40 > attacked_mask
CArray< PieceMask, 2 > effected_mask
const Progress16 progress16() const
static void eval(const NumEffectState &, MultiInt &out)
Definition: mobility.cc:280
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:587
CArray2d< int, 2, PTYPE_SIZE > ptype_board_count
CArray< MultiInt, 2 > non_pawn_ptype_attacked_pair_eval
Definition: progress.h:67
static void setUp(const Weights &weights)
Definition: ptypeEval.cc:63
void updateSub(const NumEffectState &new_state, Move last_move)
利きを持つ局面
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:834
static const std::string & home(const std::string &initialize_if_first_invocation="")
compile時に指定されたディレクトリを返す.
Definition: oslConfig.cc:239
static MultiInt eval(const NumEffectState &state)
Definition: kingTable.cc:27
static MultiInt eval(const NumEffectState &state, const CArray2d< int, 2, 3 > &gs_count)
Definition: minorPiece.cc:2250
const Square square() const
Definition: basic_type.h:832
Ptype capturePtype() const
Definition: basic_type.h:1180
static MultiInt eval(const NumEffectState &state)
Definition: king8.cc:965
const BoardMaskTable5x5 Board_Mask_Table5x5
Definition: tables.cc:119
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:1685
bool isDrop() const
Definition: basic_type.h:1150
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:1980
static MultiInt eval(const NumEffectState &state)
Definition: king8.cc:1073
const Square to() const
Definition: basic_type.h:1132
static void eval(const NumEffectState &state, MultiIntPair &out)
Definition: kingTable.cc:1050
static MultiInt eval(const NumEffectState &state, int black_pawn_count)
Definition: minorPiece.h:488
CArray< std::pair< Square, int >, 2 > rook_drop
void fill(const T_simple &value=T_simple())
Definition: container.h:67
OpenMidEndingEval(const NumEffectState &state=NumEffectState(), bool limit_progress_independent_value=! OslConfig::hasByoyomi())
static MultiInt eval(const NumEffectState &state)
Definition: kingTable.cc:1310
static MultiInt eval(const NumEffectState &state)
unsigned int random()
Definition: random.cc:4
static MultiInt eval(const NumEffectState &, int black_effect, int black_piece, int white_effect, int white_piece)
Definition: kingTable.h:219
void updateGoldSilverNearKing(const NumEffectState &state)
const Progress16 progress16() const
Definition: progress.h:257
static int evalWithUpdateCompiled(const NumEffectState &state, Move moved, int last_value)
Definition: piecePair.cc:595
bool isPromotion() const
Definition: basic_type.h:1147
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:1249
static const char * name(ProgressIndependentFeature)
const PieceMask effectedMask(Player pl) const
pl からの利きが(1つ以上)ある駒一覧
OpenMidEndingEvalDebugInfo debugInfo(const NumEffectState &state)
bool anyInRange(const BoardMask &mask) const
Definition: boardMask.h:57
static const CArray< Ptype, 7 > order
持駒の表示で良く使われる順番.
PtypeO captured(PtypeO ptypeO)
unpromoteすると共に,ownerを反転する.
Definition: basic_type.h:264
CArray< std::pair< Square, int >, 2 > knight_drop
CArray< PieceMask, 2 > effect25_supported
static MultiInt eval(const NumEffectState &state, const CArray2d< int, 2, 9 > &pawns)
Definition: majorPiece.cc:84
CArray< std::pair< Square, int >, 2 > bishop_drop
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:525
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
static MultiInt eval(int black_count, int white_count)
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:933
static void sanitize(Weights &values)
Definition: piecePair.cc:396
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:221
static int eval(const NumEffectState &state)
Definition: kingTable.cc:1918
CArray< std::pair< Square, int >, 2 > silver_drop
static MultiInt eval(const NumEffectState &state, int black_effect, int black_piece, int white_effect, int white_piece)
Definition: kingTable.h:275
static MultiIntPair eval(const NumEffectState &state)
void reset(const CArray< int, PTYPE_SIZE > &values)
Definition: ptypeEval.cc:26
const NewProgressData rawData() const
Definition: progress.h:311
void set(unsigned int i)
Definition: boardMask.h:40
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:398
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
static void eval(const NumEffectState &, MultiInt &out)
Definition: mobility.cc:225
CArray< int, PROGRESS_INDEPENDENT_FEATURE_LIMIT > progress_independent_values
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
static MultiInt eval(const NumEffectState &state)
Definition: majorPiece.cc:707
int expect(const NumEffectState &state, Move move) const
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:652
bool isMajorBasic(Ptype ptype)
Definition: basic_type.h:181
static MultiInt evalWithUpdate(const NumEffectState &state, Move moved, const MultiInt &last_values)
Definition: kingTable.cc:351
static MultiInt eval(const NumEffectState &state)
Definition: minorPiece.cc:100
const BoardMask & mask(Square p) const
p中心の5x5 の範囲のbitを立てたもの, centeringなし
Definition: boardMask.h:113
Player owner() const
Definition: basic_type.h:963
size_t dimension() const
Definition: weights.h:29
static MultiInt eval(const NumEffectState &state, const CArray< int, 5 > &black, const CArray< int, 5 > &white)
Definition: kingTable.cc:1810