39 using namespace osl::misc;
 
   41 void qsearch(
const char *filename);
 
   43 void usage(
const char *program_name)
 
   45   std::cerr << program_name << 
" [-d depth] [-s skip] [-v] csafiles\n";
 
   54 int main(
int argc, 
char **argv)
 
   56   const char *program_name = argv[0];
 
   57   bool error_flag = 
false;
 
   62   while ((c = getopt(argc, argv, 
"c:d:s:vh")) != EOF)
 
   66     case 'c':   
center = atoi(optarg);
 
   74     default:    error_flag = 
true;
 
   80   if (error_flag || (argc < 1))
 
   83   std::cerr << 
"using table record depth " << 
record_depth << 
"\n";
 
   86     for (
int i=0; i<argc; ++i)
 
   91   catch (std::exception& e)
 
   93     std::cerr << e.what() << 
"\n";
 
  119   virtual const std::string name() 
const=0;
 
  120   virtual const std::pair<int,int> alphaBeta(
Player turn,
 
  128   const std::pair<int,int>
 
  131     width.add(abs(alpha-beta));
 
  132     alpha = 
eval::max(turn, alpha, FixedEval::winThreshold(
alt(turn)));
 
  133     beta = 
eval::max(
alt(turn), beta, FixedEval::winThreshold(turn));
 
  134     const int before = (*searcher)->nodeCount();
 
  137       result = (*searcher)->search<
BLACK>(alpha, beta, eval, last_move);
 
  139       result = (*searcher)->search<
WHITE>(alpha, beta, eval, last_move);
 
  140     const int after = (*searcher)->nodeCount();
 
  141     return std::make_pair(after - before, result);
 
  146     const std::string n = name();    
 
  147     fprintf(stderr, 
"%s\t%8.3f\t%8.3f\t%10.3f\t%8.3f\n",
 
  148             n.c_str(), 
width.getAverage(), nodes.getAverage(),
 
  149             diff.getAverage(), accuracy.getAverage());
 
  165     const std::pair<int,int> alpha_beta = alphaBeta(turn, pawn_value, real_value);
 
  166     const std::pair<int,int> node_result
 
  167       = 
count(turn, alpha_beta.first, alpha_beta.second, last_move);
 
  169     nodes.add(node_result.first);
 
  170     diff.add(abs(real_value - node_result.second));
 
  171     accuracy.add(real_value == node_result.second);
 
  172     return node_result.second;
 
  182   const std::string 
name()
 const { 
return "full width"; }
 
  185     const int alpha = FixedEval::winThreshold(
alt(turn));
 
  186     const int beta = FixedEval::winThreshold(turn);
 
  187     return std::make_pair(alpha, beta);
 
  205     return pawn_value/divider;
 
  210     const int half_range=halfRange(pawn_value);
 
  211     const int alpha = center - half_range + 
eval::delta(turn);
 
  212     const int beta =  center + half_range - 
eval::delta(turn);
 
  213     return std::make_pair(alpha, beta);
 
  217 const std::string 
tos(
int val)
 
  221   std::string 
result = 
"00";
 
  222   sprintf(&result[0], 
"%d", val);
 
  239   const std::string 
name()
 const { 
 
  240     return "fixedcenter" + 
tos(center_value) +
"/"+ 
tos(divider); 
 
  252   const std::string 
name()
 const { 
 
  253     return "acc_center" + 
tos(divider); 
 
  264   int center(
int )
 const { 
return eval.value(); }
 
  265   const std::string 
name()
 const { 
 
  266     return "root_center" + 
tos(divider); 
 
  279     : 
FixedCenter(q, e, range_d, c), extend_multiplier(extend_m)
 
  282   const std::string 
name()
 const { 
 
  283     return "extend2c" + 
tos(divider) + 
tos(extend_multiplier); 
 
  287     const int root_value = eval.value();
 
  288     const int extend_range = pawn_value * extend_multiplier;
 
  289     const std::pair<int,int> alpha_beta
 
  292     int alpha = alpha_beta.first;
 
  293     int beta = alpha_beta.second;
 
  297       alpha = 
eval::min(turn, root_value+extend_range-delta, alpha);
 
  301       beta = 
eval::max(turn, root_value-extend_range+delta, beta);
 
  303     return std::make_pair(alpha, beta);
 
  317     : 
FixedCenter(q, e, range_d, c), extend_multiplier(extend_m)
 
  320   const std::string 
name()
 const { 
 
  321     return "extend2cm" + 
tos(divider) + 
tos(extend_multiplier); 
 
  325     const int root_value = eval.value();
 
  326     const int extend_range = pawn_value * extend_multiplier;
 
  328     const int half_range=halfRange(pawn_value);
 
  331     int alpha = center - half_range - 
delta;
 
  332     int beta =  center + half_range + 
delta;
 
  335       alpha = 
eval::min(turn, root_value+extend_range-delta, 
 
  336                         center - half_range/2 - delta);
 
  340       beta = 
eval::max(turn, root_value-extend_range+delta, 
 
  341                        center + half_range/2 + delta);
 
  343     return std::make_pair(alpha, beta);
 
  352   static const int extend_multiplier=2;
 
  358   const std::string 
name()
 const { 
 
  359     return "extend2o" + 
tos(divider) + 
tos(extend_multiplier); 
 
  363     const int root_value = eval.value();
 
  365     const int half_range=halfRange(pawn_value);
 
  367     int alpha = center - half_range - 
eval::delta(turn);
 
  368     int beta =  center + half_range + 
eval::delta(turn);
 
  371       beta = center + half_range*extend_multiplier + 
eval::delta(turn);
 
  375       alpha = center - half_range*extend_multiplier - 
eval::delta(turn);
 
  377     return std::make_pair(alpha, beta);
 
  395            full_searcher(&qs, ev)
 
  399     searchers.push_front(
new RootCenter(&qs, ev, 2));
 
  400     searchers.push_front(
new RootCenter(&qs, ev, 4));
 
  401     searchers.push_front(
new RootCenter(&qs, ev, 8));
 
  402     searchers.push_front(
new RootCenter(&qs, ev, 16));
 
  438     std::cerr << 
"\nrecords " << records << 
"\n";
 
  439     full_searcher.report();
 
  440     for (list_t::const_iterator p=searchers.begin(); p!=searchers.end(); ++p)
 
  450     const Player turn = state.turn();
 
  457     const int real_value_dummy = 0;
 
  459       = full_searcher.search(turn, pawn_value, real_value_dummy, last_move);
 
  461     for (list_t::iterator p=searchers.begin(); p!=searchers.end(); ++p)
 
  464       (*p)->search(turn, pawn_value, real_value, last_move);
 
  469     Record rec=CsaFile(filename).getRecord();
 
  470     state = NumEffectState(rec.getInitialState());
 
  472     const vector<osl::Move> 
moves=rec.getMoves();
 
  482       if (i >= moves.size())
 
  484       const Move move = moves[i++];
 
  485       state.makeMove(move);
 
  486       ev.update(state, move);
 
  495 void qsearch(
const char *filename)