Target.cc

Go to the documentation of this file.

/*
 * Target.cc
 *
 * Author: William Ma <https://github.com/williampma>
 *
 * Copyright (C) 2015 OpenCog Foundation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License v3 as
 * published by the Free Software Foundation and including the exceptions
 * at http://opencog.org/wiki/Licenses
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program; if not, write to:
 * Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <opencog/util/random.h>
#include <opencog/atoms/bind/PatternUtils.h>
#include <opencog/atomutils/AtomUtils.h>

#include "Target.h"

using namespace opencog;

Target::Target(AtomSpace& as, const Handle& h, const Handle& hvardecl) : _as(as)
{
    _htarget_external = h;
    _htarget_internal = _as.add_atom(h);
    _selection_count = 0;

    _vardecl = hvardecl;

    HandleSeq vars = VariableListCast(_vardecl)->get_variables().varseq;

    // _varmap is a map that bases on the external space
    for (auto& hv : vars)
        _varmap[hv] = UnorderedHandleSet();
}

void Target::store_step(const Rule& r, const HandleSeq& premises)
{
    // XXX TODO think of a good structure for storing the inference step
    // XXX TODO if the rule was actually applied, store the change to the TV?
    _as.add_link(SET_LINK,
                 _htarget_internal,
                 _as.add_node(CONCEPT_NODE, r.get_name()),
                 _as.add_link(LIST_LINK, premises));
}

void Target::store_varmap(VarMultimap& vm)
{
    for (auto& p : vm)
    {
        if (_varmap.count(p.first) == 1)
            _varmap[p.first].insert(p.second.begin(), p.second.end());
    }
}

void Target::store_varmap(VarMap& vm)
{
    for (auto& p : vm)
    {
        if (_varmap.count(p.first) == 1)
            _varmap[p.first].insert(p.second);
    }
}

unsigned int Target::rule_count(const Rule& r)
{
    Handle hname = _as.add_node(CONCEPT_NODE, r.get_name());
    HandleSeq q = get_neighbors(_htarget_internal, false, true,
                                SET_LINK, false);

    return std::count(q.begin(), q.end(), hname);
}


//==================================================================


TargetSet::TargetSet() : _total_selection(0)
{

}

TargetSet::~TargetSet()
{

}

void TargetSet::clear()
{
    _history_space.clear();
    _targets_map.clear();
}

void TargetSet::emplace(Handle h, Handle hvardecl)
{
    if (_targets_map.count(h) == 1)
        return;

    _targets_map.insert(std::pair<Handle, Target>(h, Target(_history_space, h, hvardecl)));
}

unsigned int TargetSet::size()
{
    return _targets_map.size();
}

Target& TargetSet::select()
{
    HandleSeq handles;
    std::vector<double> weights;
    for (auto& p : _targets_map)
    {
        handles.push_back(p.first);

        // XXX TODO add more criteria to the weight calculation
        weights.push_back(_total_selection - p.second.get_selection_count() + 1);
    }

    Target& t = _targets_map.at(handles[randGen().randDiscrete(weights)]);
    t.increment_selection_count();

    _total_selection++;

    return t;
}

Target& TargetSet::get(Handle& h)
{
    return _targets_map.at(h);
}