ArithmeticLink.cc

Go to the documentation of this file.

/*
 * opencog/atoms/reduct/ArithmeticLink.cc
 *
 * Copyright (C) 2015 Linas Vepstas
 * All Rights Reserved
 *
 * 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 Arithmetic 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:
 * Arithmetic Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <limits>

#include <opencog/atomspace/atom_types.h>
#include <opencog/atomspace/ClassServer.h>
#include <opencog/atoms/NumberNode.h>
#include <opencog/atoms/execution/Instantiator.h>
#include "ArithmeticLink.h"

using namespace opencog;

ArithmeticLink::ArithmeticLink(const HandleSeq& oset,
                   TruthValuePtr tv,
                   AttentionValuePtr av)
    : FoldLink(ARITHMETIC_LINK, oset, tv, av)
{
    init();
}

ArithmeticLink::ArithmeticLink(Type t, const HandleSeq& oset,
                   TruthValuePtr tv,
                   AttentionValuePtr av)
    : FoldLink(t, oset, tv, av)
{
    if (not classserver().isA(t, ARITHMETIC_LINK))
        throw InvalidParamException(TRACE_INFO, "Expecting a ArithmeticLink");
    init();
}

ArithmeticLink::ArithmeticLink(Type t, const Handle& a, const Handle& b,
                   TruthValuePtr tv,
                   AttentionValuePtr av)
    : FoldLink(t, a, b, tv, av)
{
    if (not classserver().isA(t, ARITHMETIC_LINK))
        throw InvalidParamException(TRACE_INFO, "Expecting a ArithmeticLink");
    init();
}

ArithmeticLink::ArithmeticLink(Link& l)
    : FoldLink(l)
{
    Type tscope = l.getType();
    if (not classserver().isA(tscope, ARITHMETIC_LINK))
        throw InvalidParamException(TRACE_INFO, "Expecting a ArithmeticLink");
    init();
}

void ArithmeticLink::init(void)
{
    knild = std::numeric_limits<double>::quiet_NaN();
}

// ===========================================================
Handle ArithmeticLink::reduce(void)
{
    Handle road(reorder());
    ArithmeticLinkPtr alp(ArithmeticLinkCast(road));

    Handle red(alp->FoldLink::reduce());

    alp = ArithmeticLinkCast(red);
    if (NULL == alp) return red;
    return alp->reorder();
}

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

Handle ArithmeticLink::reorder(void)
{
    HandleSeq vars;
    HandleSeq exprs;
    HandleSeq numbers;

    for (const Handle& h : _outgoing)
    {
        if (h->getType() == VARIABLE_NODE)
            vars.push_back(h);
        else if (h->getType() == NUMBER_NODE)
            numbers.push_back(h);
        else
            exprs.push_back(h);
    }

    HandleSeq result;
    for (const Handle& h : vars) result.push_back(h);
    for (const Handle& h : exprs) result.push_back(h);
    for (const Handle& h : numbers) result.push_back(h);

    Handle h(FunctionLink::factory(getType(), result));
    if (NULL == _atomTable) return h;

    return _atomTable->getAtomSpace()->add_atom(h);
}

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

static inline double get_double(AtomSpace *as, Handle h)
{
    NumberNodePtr nnn(NumberNodeCast(h));
    if (nnn == NULL)
        throw RuntimeException(TRACE_INFO,
              "Expecting a NumberNode, got %s",
             classserver().getTypeName(h->getType()).c_str());

    return nnn->get_value();
}

Handle ArithmeticLink::execute(AtomSpace* as) const
{
    // XXX FIXME, we really want the instantiator to do the work
    // here, but there is a giant circular-shared-library mess
    // that results if we do this. So i'm disablig for now.
#ifdef CIRCULAR_SHARED_LIBS
    Instantiator inst(as);
#endif
    double sum = knild;
    for (Handle h: _outgoing)
    {
#ifdef CIRCULAR_SHARED_LIBS
        h = inst.execute(h);
#else
        FunctionLinkPtr flp = FunctionLinkCast(h);

        // Arghh.  The cast should have been enough, but we currently
        // can't store these in the atomsapce, due to circular shared
        // lib dependencies.
        if (NULL == flp and classserver().isA(h->getType(), FUNCTION_LINK))
            flp = FunctionLinkCast(FunctionLink::factory(LinkCast(h)));
        if (NULL != flp)
            h = flp->execute();
#endif
        sum = konsd(sum, get_double(as, h));
    }

    if (as) return as->add_atom(createNumberNode(sum));
    return Handle(createNumberNode(sum));
}
// ===========================================================