Exemplo n.º 1
0
SgPoint GoUctSearchUtil::TrompTaylorPassCheck(SgPoint move,
                                              const GoUctSearch& search)
{
    const GoBoard& bd = search.Board();
    bool isFirstPass = (bd.GetLastMove() != SG_PASS);
    bool isTrompTaylorRules = bd.Rules().CaptureDead();
    if (move != SG_PASS || ! isTrompTaylorRules || ! isFirstPass)
        return move;
    float komi = bd.Rules().Komi().ToFloat();
    float trompTaylorScore = GoBoardUtil::TrompTaylorScore(bd, komi);
    if (search.ToPlay() != SG_BLACK)
        trompTaylorScore *= -1;
    const SgUctTree& tree = search.Tree();
    const SgUctNode& root = tree.Root();
    SgUctValue value = root.Mean();
    SgUctValue trompTaylorWinValue = (trompTaylorScore > 0 ? 1 : 0);
    if (value < trompTaylorWinValue)
        return move;
    SgDebug() << "GoUctSearchUtil::TrompTaylorPassCheck: bad pass move value="
              << value << " trompTaylorScore=" << trompTaylorScore << '\n';
    std::vector<SgMove> excludeMoves;
    excludeMoves.push_back(SG_PASS);
    const SgUctNode* bestChild = search.FindBestChild(root, &excludeMoves);
    if (bestChild == 0)
    {
        SgDebug() <<
            "GoUctSearchUtil::TrompTaylorPassCheck: "
            "(no second best move found)\n";
        return move;
    }
    return bestChild->Move();
}
Exemplo n.º 2
0
bool DfpnSolver::CheckAbort()
{
    if (! m_aborted)
    {
        if (SgUserAbort()) 
        {
            m_aborted = true;
            SgDebug() << "DfpnSolver::CheckAbort(): Abort flag!\n";
        }
        else if (m_timelimit > 0)
        {
            if (m_checkTimerAbortCalls == 0)
            {
                double elapsed = m_timer.GetTime();
                if (elapsed > m_timelimit)
                {
                    m_aborted = true;
                    SgDebug() << "DfpnSolver::CheckAbort(): Timelimit!\n";
                }
                else if (m_numMIDcalls < 100)
                    m_checkTimerAbortCalls = 10;
                else
                {
                    size_t midsPerSec = static_cast<size_t>
                        (double(m_numMIDcalls) / elapsed);
                    m_checkTimerAbortCalls = midsPerSec / 2;
                }
            }
            else
                --m_checkTimerAbortCalls;
        }
    }
    return m_aborted;
}
Exemplo n.º 3
0
void GoAutoBook::Merge(const GoAutoBook& other)
{
    SgDebug() << "GoAutoBook::Merge()\n";
    std::size_t newLeafs = 0;
    std::size_t newInternal = 0;
    std::size_t leafsInCommon = 0;
    std::size_t internalInCommon = 0;
    std::size_t leafToInternal = 0;
    for (Map::const_iterator it = other.m_data.begin();
         it != other.m_data.end(); ++it)
    {
        Map::iterator mine = m_data.find(it->first);
        SgBookNode newNode(it->second);
        if (mine == m_data.end())
        {
            m_data[it->first] = it->second;
            if (newNode.IsLeaf())
                newLeafs++;
            else
                newInternal++;
        }
        else
        {
            SgBookNode oldNode(mine->second);
            if (newNode.IsLeaf() && oldNode.IsLeaf())
            {
                newNode.m_heurValue = 0.5f * (newNode.m_heurValue 
                                             + oldNode.m_heurValue);
                m_data[it->first] = newNode;
                leafsInCommon++;
            }
            else if (! newNode.IsLeaf())
            {
                // Take the max of the count; can't just add them
                // together because then merging a book with itself
                // doubles the counts of everything, which doesn't
                // make sense. Need the parent of these books and do a
                // three-way merge if we want the counts to be
                // accurate after the merge.  I don't think it matters
                // that much.
                newNode.m_count = std::max(newNode.m_count, oldNode.m_count);
                m_data[it->first] = newNode;
                if (! oldNode.IsLeaf())
                    internalInCommon++;
                else 
                    leafToInternal++;
            }
        }
    }
    SgDebug() << "Statistics\n"
              << "New Leafs        " << newLeafs << '\n'
              << "New Internal     " << newInternal << '\n'
              << "Common Leafs     " << leafsInCommon << '\n'
              << "Common Internal  " << internalInCommon << '\n'
              << "Leaf to Internal " << leafToInternal << '\n';
}
Exemplo n.º 4
0
GoAutoBook::GoAutoBook(const std::string& filename,
                       const GoAutoBookParam& param)
    : m_param(param), 
      m_filename(filename)
{
    std::ifstream is(filename.c_str());
    if (! is)
    {
        std::ofstream of(filename.c_str());
        if (! of)
            throw SgException("Invalid file name!");
        of.close();
    }
    else
    {
        while (is)
        {
            std::string line;
            std::getline(is, line);
            if (line.size() < 19)
                continue;
            std::string str;
            std::istringstream iss(line);
            iss >> str;
            SgHashCode hash;
            hash.FromString(str);
            SgBookNode node(line.substr(19));
            m_data[hash] = node;
        }
        SgDebug() << "GoAutoBook: Parsed " << m_data.size() << " lines.\n";
    }
}
Exemplo n.º 5
0
void GoAutoBook::ImportHashValuePairs(std::istream& in)
{
    std::size_t count = 0;
    while (in)
    {
        SgHashCode hash;
        std::string hashStr;
        in >> hashStr;
        hash.FromString(hashStr);
        float value;
        if (! in) 
            break;
        in >> value;
        if (m_data.count(hash) == 0)
        {
            std::ostringstream os;
            os << "Unknown hash: " << hash << '\n';
            throw SgException(os.str());
        }
        SgBookNode node(m_data[hash]);
        node.m_heurValue = value;
        node.m_value = value;
        m_data[hash] = node;
        count++;
    }
    SgDebug() << "GoAutoBook::ImportHashValue: imported " 
              << count << " values.\n";
}
Exemplo n.º 6
0
void DfpnSolver::PrintStatistics(SgEmptyBlackWhite winner,
                                 const PointSequence& pv) const
{
    std::ostringstream os;
    os << '\n'
       << SgWriteLabel("MID calls") << m_numMIDcalls << '\n'
       << SgWriteLabel("Generate moves") << m_generateMoves << '\n'
       << SgWriteLabel("Terminal") << m_numTerminal << '\n'
       << SgWriteLabel("Work") << m_numMIDcalls + m_numTerminal << '\n'
       << SgWriteLabel("Wasted Work") << m_totalWastedWork
       << " (" << (double(m_totalWastedWork) * 100.0 
                   / double(m_numMIDcalls + m_numTerminal)) << "%)\n"
       << SgWriteLabel("Elapsed Time") << m_timer.GetTime() << '\n'
       << SgWriteLabel("MIDs/sec") 
       << double(m_numMIDcalls) / m_timer.GetTime() << '\n'
       << SgWriteLabel("generates/sec")
       << double(m_generateMoves) / m_timer.GetTime() << '\n'
       << SgWriteLabel("Cnt prune sib") << m_prunedSiblingStats.Count() << '\n'
       << SgWriteLabel("Avg prune sib");
    m_prunedSiblingStats.Write(os);
    os << '\n' << SgWriteLabel("Move Index");
    m_moveOrderingIndex.Write(os);
    os << '\n' << SgWriteLabel("Move Percent");
    m_moveOrderingPercent.Write(os);
    os << '\n' << SgWriteLabel("Delta Increase");
    m_deltaIncrease.Write(os);
    os << '\n'
       << SgWriteLabel("Winner") << SgEBW(winner) << '\n';
    WriteMoveSequence(os, pv);
    os << '\n';
    if (m_hashTable)
        os << '\n' << *m_hashTable << '\n';
    SgDebug() << os.str();
}
Exemplo n.º 7
0
void GoRegionBoard::OnExecutedUncodedMove(int move, SgBlackWhite moveColor)
{
    if (DEBUG_REGION_BOARD)
        SgDebug() << "OnExecutedUncodedMove " << SgWritePoint(move) << '\n';
    {
        m_stack.StartMoveInfo();
        if (move != SG_PASS)
        {
            SG_ASSERT(! Board().LastMoveInfo(GO_MOVEFLAG_SUICIDE));
            // can't handle yet,
            // should be forbidden anyway. @todo allowed in Chinese rules.
            bool fWasCapture = Board().LastMoveInfo(GO_MOVEFLAG_CAPTURING);

            UpdateBlock(move, moveColor);

            {
                GoRegion* r = PreviousRegionAt(move, moveColor);
                bool split = GoEyeUtil::IsSplitPt(move, r->Points());

                r->OnAddStone(move);
                PushStone(r, move);
                SgPointSet points = r->Points();
                // needed even after RemoveRegion(r).
                if (split || points.IsEmpty())
                // must remove old region before generating new ones,
                // because removing clears m_anchor[]
                    RemoveRegion(r);

                if (split) // find new regions
                {
                    for (SgConnCompIterator it(points, Board().Size());
                         it; ++it)
                        GenRegion(*it, moveColor);
                }
            }

            if (fWasCapture)
            {
            //  FindNewNeighborRegions(move, moveColor);
                MergeAdjacentAndAddBlock(move, SgOppBW(moveColor));
            }

            m_code = Board().GetHashCode();
            if (HEAVYCHECK)
                CheckConsistency();
        }
    }

    {
        for (SgBWIterator it; it; ++it)
        {
            SgBlackWhite color(*it);
            for (SgVectorIteratorOf<GoRegion> it(AllRegions(color)); it; ++it)
            {   GoRegion* r1 = *it;
                if (! r1->IsValid())
                    r1->ComputeBasicFlags();
            }
        }
    }
}
Exemplo n.º 8
0
std::vector< std::vector<SgMove> > GoAutoBook::ParseWorkList(std::istream& in)
{
    std::vector< std::vector<SgMove> > ret;
    while (in)
    {
        std::string line;
        std::getline(in, line);
        if (line == "")
            continue;
        std::vector<SgMove> var;
        std::istringstream in2(line);
        while (true)
        {
            std::string s;
            in2 >> s;
            if (! in2 || s == "|")
                break;
            std::istringstream in3(s);
            SgPoint p;
            in3 >> SgReadPoint(p);
            if (! in3)
                throw SgException("Invalid point");
            var.push_back(p);
        }
        ret.push_back(var);
    }
    SgDebug() << "GoAutoBook::ParseWorkList: Read " << ret.size() 
              << " variations.\n";
    return ret;
}
Exemplo n.º 9
0
SgEmptyBlackWhite DfpnSolver::StartSearch(DfpnHashTable& hashTable, 
                                          PointSequence& pv,
                                          const DfpnBounds& maxBounds)
{
    m_aborted = false;
    m_hashTable = &hashTable;
    m_numTerminal = 0;
    m_numMIDcalls = 0;
    m_generateMoves = 0;
    m_totalWastedWork = 0;
    m_prunedSiblingStats.Clear();
    m_moveOrderingPercent.Clear();
    m_moveOrderingIndex.Clear();
    m_deltaIncrease.Clear();
    m_checkTimerAbortCalls = 0;

    // Skip search if already solved
    DfpnData data;
    if (TTRead(data) && data.m_bounds.IsSolved())
    {
        SgDebug() << "Already solved!\n";
        const SgEmptyBlackWhite toPlay = GetColorToMove();
        SgEmptyBlackWhite w = Winner(data.m_bounds.IsWinning(), toPlay);
        GetPVFromHash(pv);
        SgDebug() << SgEBW(w) << " wins!\n";
        WriteMoveSequence(SgDebug(), pv);
        return w;
    }

    m_timer.Start();
    DfpnHistory history;
    MID(maxBounds, history);
    m_timer.Stop();

    GetPVFromHash(pv);
    SgEmptyBlackWhite winner = SG_EMPTY;
    if (TTRead(data) && data.m_bounds.IsSolved())
    {
        const SgEmptyBlackWhite toPlay = GetColorToMove();
        winner = Winner(data.m_bounds.IsWinning(), toPlay);
    }
    PrintStatistics(winner, pv);

    if (m_aborted)
        SgWarning() << "Search aborted.\n";
    return winner;
}
Exemplo n.º 10
0
SgMove GoAutoBook::FindBestChild(GoAutoBookState& state) const
{
    std::size_t bestCount = 0;
    SgMove bestMove = SG_NULLMOVE;
    float bestScore = 100.0f;
    SgBookNode node;
    if (!Get(state, node))
        return SG_NULLMOVE;
    if (node.IsLeaf())
        return SG_NULLMOVE;
    for (GoBoard::Iterator it(state.Board()); it; ++it)
    {
        if (state.Board().IsLegal(*it))
        {
            state.Play(*it);
            if (m_disabled.count(state.GetHashCode()) > 0)
                SgDebug() << "Ignoring disabled move " 
                          << SgWritePoint(*it) << '\n';
            // NOTE: Terminal nodes aren't supported at this time, so 
            // we ignore them here.
            else if (Get(state, node) 
                     && !node.IsTerminal() 
                     && node.m_count >= m_param.m_usageCountThreshold)
            {
                if (m_param.m_selectType == GO_AUTOBOOK_SELECT_COUNT)
                {
                    // Select by count, tiebreak by value.
                    if (node.m_count > bestCount)
                    {
                        bestCount = node.m_count;
                        bestMove = *it;
                        bestScore = node.m_value;
                    }
                    // NOTE: do not have access to inverse function,
                    // so we're minimizing here as a temporary solution. 
                    else if (node.m_count == bestCount
                             && node.m_value < bestScore)
                    {
                        bestMove = *it;
                        bestScore = node.m_value;
                    }
                }
                else if (m_param.m_selectType == GO_AUTOBOOK_SELECT_VALUE)
                {
                    // NOTE: do not have access to inverse function,
                    // so we're minimizing here as a temporary solution. 
                    if (node.m_value < bestScore)
                    {
                        bestMove = *it;
                        bestScore = node.m_value;
                    }
                }
            }
            state.Undo();
        }
    }
    return bestMove;
}
Exemplo n.º 11
0
void GoRegionBoard::ExecuteMovePrologue()
{
    if (! UpToDate()) // full recomputation
    {
        if (DEBUG_REGION_BOARD)
            SgDebug() << "recompute everything\n";
        GenBlocksRegions();
    }
}
void GoUctFeatureKnowledgeFactory::ReadWeights()
{
    m_weights = FeFeatureWeights::ReadDefaultWeights();
    SgDebug() << "GoUctFeatureKnowledgeFactory Read weights for "
              << m_weights.m_nuFeatures
              << " features with k = " << m_weights.m_k
              << ", minID = " << m_weights.m_minID
              << ", maxID = " << m_weights.m_maxID
              << '\n';
}
Exemplo n.º 13
0
GoBlock* GoRegionBoard::GetBlock(const SgPointSet& boundary,
                                 SgBlackWhite color) const
{
    SG_ASSERT(UpToDate());

    for (SgVectorIteratorOf<GoBlock> it(AllBlocks(color)); it; ++it)
    {   if (boundary.SubsetOf((*it)->Stones()))
        /* */ return *it; /* */
    }

    SgDebug() << "ERROR: no block on set";
    const int size = Board().Size();
    boundary.Write(SgDebug(), size);
    SgDebug() << "blocks:";
    for (SgVectorIteratorOf<GoBlock> it(AllBlocks(color));it; ++it)
        (*it)->Stones().Write(SgDebug(), size);

    SG_ASSERT(false);
    return 0;
}
Exemplo n.º 14
0
void GoSafetySolver::Merge(GoChain* c1, GoChain* c2,
                           GoRegion* r, bool bySearch)
{
    SG_ASSERT(! r->GetFlag(GO_REGION_USED_FOR_MERGE));
    r->SetFlag(GO_REGION_USED_FOR_MERGE, true);
    
    GoChainCondition* c = 0;
    if (bySearch)
        c = new GoChainCondition(GO_CHAIN_BY_SEARCH);
    else
    {
        SgPoint lib1, lib2;
        r->Find2FreeLibs(c1, c2, &lib1, &lib2);
        c = new GoChainCondition(GO_CHAIN_TWO_LIBERTIES_IN_REGION,
                                 lib1, lib2);
    }
    
    GoChain* m = new GoChain(c1, c2, c);

    SgBlackWhite color = c1->Color();
    bool found = Regions()->AllChains(color).Exclude(c1);
    SG_DEBUG_ONLY(found);
    SG_ASSERT(found);
    found = Regions()->AllChains(color).Exclude(c2);
    SG_ASSERT(found);
    Regions()->AllChains(color).Include(m);
    SG_ASSERT(Regions()->AllChains(color).UniqueElements());

    for (SgVectorIteratorOf<GoRegion>
         it(Regions()->AllRegions(color)); it; ++it)
    {
        GoRegion* r = *it;
        bool replace1 = r->ReplaceChain(c1, m);
        bool replace2 = r->ReplaceChain(c2, m);
        if (replace1 || replace2)
        {
            r->ReInitialize();
            r->ComputeFlag(GO_REGION_STATIC_1VITAL);
        }
    }

    if (DEBUG_MERGE_CHAINS)
    {
        SgDebug() << "\nmerge:";
        c1->WriteID(SgDebug());
        SgDebug() << " + ";
        c2->WriteID(SgDebug());
        SgDebug() << " = ";
        m->WriteID(SgDebug());
        SgDebug() << '\n';
    }

    delete c1;
    delete c2;
}
Exemplo n.º 15
0
void GoUctSearch::DisplayGfx()
{
    SgDebug() << "gogui-gfx:\n";
    switch (m_liveGfx)
    {
    case GOUCT_LIVEGFX_COUNTS:
        GoUctUtil::GfxBestMove(*this, m_toPlay, SgDebug());
        GoUctUtil::GfxMoveValues(*this, m_toPlay, SgDebug());
        GoUctUtil::GfxCounts(Tree(), SgDebug());
        GoUctUtil::GfxStatus(*this, SgDebug());
        break;
    case GOUCT_LIVEGFX_SEQUENCE:
        GoUctUtil::GfxSequence(*this, m_toPlay, SgDebug());
        GoUctUtil::GfxStatus(*this, SgDebug());
        break;
    case GOUCT_LIVEGFX_NONE:
        SG_ASSERT(false); // Should only be called when LiveGfx is enabled
        break;
    }
    SgDebug() << '\n';
}
Exemplo n.º 16
0
void GoRegionBoard::Clear()
{
    if (DEBUG_REGION_BOARD)
        SgDebug() << "Clear\n";
    for (SgBWIterator it; it; ++it)
    {
        SgBlackWhite color(*it);
        for (SgVectorIteratorOf<GoBlock> it1(AllBlocks(color)); it1; ++it1)
            delete *it1;
        for (SgVectorIteratorOf<GoRegion> it2(AllRegions(color)); it2; ++it2)
            delete *it2;
        for (SgVectorIteratorOf<GoChain> it3(AllChains(color)); it3; ++it3)
            delete *it3;
    }
    m_allBlocks[SG_BLACK].Clear();
    m_allBlocks[SG_WHITE].Clear();
    m_allRegions[SG_BLACK].Clear();
    m_allRegions[SG_WHITE].Clear();
    m_allChains[SG_BLACK].Clear();
    m_allChains[SG_WHITE].Clear();
    m_stack.Clear();
    m_code.Invalidate();
    m_invalid = true;
    m_computedHealthy = false;
    m_boardSize = m_board.Size();

    for (SgBWIterator it; it; ++it)
    {
        SgBlackWhite color(*it);
        for (SgPoint p = SgPointUtil::Pt(1, 1);
             p <= SgPointUtil::Pt(SG_MAX_SIZE, SG_MAX_SIZE);
             ++p)
        {
            m_region[color][p] = 0;
        }
    }
    for (SgPoint p = SgPointUtil::Pt(1, 1);
         p <= SgPointUtil::Pt(SG_MAX_SIZE, SG_MAX_SIZE); ++p)
        m_block[p] = 0;
}
Exemplo n.º 17
0
void GoRegionBoard::OnUndoneMove()
// Called after a move has been undone. The board is guaranteed to be in
// a legal state.
{
    //SG_ASSERT(false); // incremental code is incomplete, do not call
    if (DEBUG_REGION_BOARD)
        SgDebug() << "OnUndoneMove " << '\n';

    const bool IS_UNDO = false;
    SgVectorOf<GoRegion> changed;

    for (int val = m_stack.PopEvent(); val != SG_NEXTMOVE;
         val = m_stack.PopEvent())
    {

        switch (val)
        {
            case REGION_REMOVE:
            {   GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
                AddRegion(r, IS_UNDO);
                changed.Insert(r);
            }
            break;
            case REGION_ADD:
            {   GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
                RemoveRegion(r, IS_UNDO);
            }
            break;
            case REGION_REMOVE_BLOCK:
            {   GoBlock* b = static_cast<GoBlock*>(m_stack.PopPtr());
                AddBlock(b, IS_UNDO);
                for (int nu = m_stack.PopInt(); nu > 0; --nu)
                {
                    GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
                    if (CHECK)
                        SG_ASSERT(! r->Blocks().Contains(b));
                    r->BlocksNonConst().PushBack(b);
                    changed.Insert(r);
                }
            }
            break;
            case REGION_ADD_BLOCK:
            {   GoBlock* b = static_cast<GoBlock*>(m_stack.PopPtr());
                RemoveBlock(b, IS_UNDO, true);
            }
            break;
            case REGION_ADD_STONE:
            {   GoRegion* r = static_cast<GoRegion*>(m_stack.PopPtr());
                SgPoint p = m_stack.PopInt();
                r->OnRemoveStone(p);
                m_region[r->Color()][p] = r;
                changed.Insert(r);
            }
            break;
            case REGION_ADD_STONE_TO_BLOCK:
            {   GoBlock* b = static_cast<GoBlock*>(m_stack.PopPtr());
                SgPoint p = m_stack.PopInt();
                b->RemoveStone(p);
                m_block[p] = 0;
            }
            break;
            default:
                SG_ASSERT(false);
        }
    }

    for (SgVectorIteratorOf<GoRegion> it(changed); it; ++it)
    {
        (*it)->ResetNonBlockFlags();
        (*it)->ComputeBasicFlags();
    }

    if (HEAVYCHECK)
    {
        for (SgBWIterator it; it; ++it)
        {
            SgBlackWhite color(*it);
            for (SgVectorIteratorOf<GoRegion> it(AllRegions(color)); it; ++it)
            {
                const GoRegion* r = *it;
                SG_UNUSED(r);
                SG_ASSERT(r->IsValid());
            }
        }
    }

    m_code = Board().GetHashCode();
    if (HEAVYCHECK)
        CheckConsistency();
}
Exemplo n.º 18
0
void GoUctState::AssertionHandler::Run()
{
    m_state.Dump(SgDebug());
}
Exemplo n.º 19
0
SgMove GoAutoBook::FindBestChild(GoAutoBookState& state) const
{
    std::size_t bestCount = 0;
    SgMove bestMove = SG_NULLMOVE;
    SgMove bestIgnoredMove = SG_NULLMOVE;
    float bestScore = 100.0f;
    float bestIgnoredMoveScore = 100.0f;
    SgBookNode node;
    // Check for forced moves first
    // Note this will check for forced moves even if the current
    // state is not in the book.
    for (GoBoard::Iterator it(state.Board()); it; ++it)
    {
        if (state.Board().IsLegal(*it))
        {
            state.Play(*it);
            if (m_forced.count(state.GetHashCode()) > 0)
            {
                SgDebug() << "Playing forced move " 
                          << SgWritePoint(*it) << '\n';
                return *it;
            }
            state.Undo();
        }
    }
    if (! Get(state, node))
        return SG_NULLMOVE;
    if (node.IsLeaf())
        return SG_NULLMOVE;
    for (GoBoard::Iterator it(state.Board()); it; ++it)
    {
        if (state.Board().IsLegal(*it))
        {
            state.Play(*it);
            if (m_disabled.count(state.GetHashCode()) > 0)
                SgDebug() << "Ignoring disabled move " 
                          << SgWritePoint(*it) << '\n';
            // NOTE: Terminal nodes aren't supported at this time, so 
            // we ignore them here.
            else if (  Get(state, node) 
                    && ! node.IsTerminal() 
                    )
            {
            	if (node.m_count >= m_param.m_usageCountThreshold)
                {
                    if (m_param.m_selectType == GO_AUTOBOOK_SELECT_COUNT)
                    {
                        // Select by count, tiebreak by value.
                        if (node.m_count > bestCount)
                        {
                            bestCount = node.m_count;
                            bestMove = *it;
                            bestScore = node.m_value;
                        }
                        // NOTE: do not have access to inverse function,
                        // so we're minimizing here as a temporary solution. 
                        else if (node.m_count == bestCount
                                 && node.m_value < bestScore)
                        {
                            bestMove = *it;
                            bestScore = node.m_value;
                        }
                    }
                    else if (m_param.m_selectType == GO_AUTOBOOK_SELECT_VALUE)
                    {
                        // NOTE: do not have access to inverse function,
                        // so we're minimizing here as a temporary solution. 
                        if (node.m_value < bestScore)
                        {
                            bestMove = *it;
                            bestScore = node.m_value;
                        }
                    }
                }
                else // node.m_count < m_param.m_usageCountThreshold
                if (  m_param.m_selectType == GO_AUTOBOOK_SELECT_VALUE
                   && node.m_value < bestIgnoredMoveScore
                   )
                {
                   bestIgnoredMove = *it;
                   bestIgnoredMoveScore = node.m_value;
                }
            }
            state.Undo();
        }
    }
    if (bestMove != SG_NULLMOVE && bestIgnoredMoveScore < bestScore)
    {
        SgDebug() << "Ignoring autobook move "
        << SgWritePoint(bestMove)
        << " since best ignored inverse value " 
        << std::setprecision(5)
        << bestIgnoredMoveScore
        << " of move " 
        << SgWritePoint(bestIgnoredMove)
        << " is better than best value above usage threshold " 
        << bestScore << '\n';
        
    	return SG_NULLMOVE;
    }
    return bestMove;
}