infeng_hook.h

Go to the documentation of this file.

// Search Node inference engine meta computation hook implementation -*- C++ -*-

// $Id: infeng_hook.h 518 2008-04-01 11:40:39Z mihaly $
// Copyright (C) 2008 Hermann Schichl
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library 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
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef _INFENG_HOOK_H
#define _INFENG_HOOK_H

#include <comp_hook.h>
#include <inference_engine.h>
#include <triple>
#include <print_seq.h>
#include <print_matrix.h>
#include <counted_ptr.h>

namespace coco {


class inference_engine_comp_hook : public wnc_hook_base
{
private:
  counted_ptr<inference_engine> ie;

  control_data ie_ctrl;

  std::map<std::triple<std::string,bool,int>,
                         std::pair<std::string,basic_alltype> > info_to_col;

  double thresh;

public:
  inference_engine_comp_hook(inference_engine *_ie, const control_data& _cd,
                             double _thr = -COCO_INF)
                : wnc_hook_base("inference engine"), 
                  ie(_ie), ie_ctrl(_cd), info_to_col(), thresh(_thr)
    {}

  inference_engine_comp_hook(inference_engine *_ie, const control_data& _cd,
              const std::map<std::triple<std::string,bool,int>,
                                   std::pair<std::string,basic_alltype> >& _itc,
              double _thr = -COCO_INF)
                : wnc_hook_base("inference engine"),
                  ie(_ie), ie_ctrl(_cd), info_to_col(_itc), thresh(_thr)
    {}

  inference_engine_comp_hook(const inference_engine_comp_hook& iec)
                : wnc_hook_base(iec), ie(iec.ie), ie_ctrl(iec.ie_ctrl),
                  info_to_col(iec.info_to_col), thresh(iec.thresh)
    {}

  virtual ~inference_engine_comp_hook() { }

  inference_engine_comp_hook* new_copy() const
        { return new inference_engine_comp_hook(*this); }

  void operator()(const work_node& wn, dbt_row& dbr,
                  std::list<delta>* add_ds = NULL,
                  std::list<certificate>* add_cs = NULL) const
  {
    /* call the inference engine for the current work node */
    ptr<work_node> pwn(& const_cast<work_node&>(wn));
    if(!ie->update_engine(pwn))
      throw api_exception(apiee_search_graph, std::string("Inferene Engine `")+
          ie->get_name()+"': update_engine returned false.");
    ie_return_type ier(ie->infer(ie_ctrl));

    std::map<std::triple<std::string,bool,int>,
                      std::pair<std::string,basic_alltype> >::const_iterator cms;
    basic_alltype bat;

    /* update the columns */
    for(cms = info_to_col.begin(); cms != info_to_col.end(); ++cms)
    {
      if((*cms).first.second)
        bat = ier.information((*cms).first.first);
      else
        bat = ier.information((*cms).first.first, (*cms).first.third);
      switch(bat.contents_type())
      {
        case ALLTYPE_INTERVAL:
          dbr.add((*cms).second.first, bat.ni());
          break;
        case ALLTYPE_DOUBLE:
          dbr.add((*cms).second.first, bat.nd());
          break;
        case ALLTYPE_UINT:
          dbr.add((*cms).second.first, bat.nu());
          break;
        case ALLTYPE_INT:
          dbr.add((*cms).second.first, bat.nn());
          break;
        case ALLTYPE_BOOL:
          dbr.add((*cms).second.first, bat.nb());
          break;
        case ALLTYPE_EMPTY:
          break;
        case ALLTYPE_ALLOCED_B:
          dbr.add((*cms).second.first, bat.b());
          break;
        case ALLTYPE_ALLOCED_N:
          dbr.add((*cms).second.first, bat.n());
          break;
        case ALLTYPE_ALLOCED_U:
          dbr.add((*cms).second.first, bat.u());
          break;
        case ALLTYPE_ALLOCED_D:
          dbr.add((*cms).second.first, bat.d());
          break;
        case ALLTYPE_ALLOCED_I:
          dbr.add((*cms).second.first, bat.i());
          break;
        case ALLTYPE_ALLOCED_C:
          dbr.add((*cms).second.first, bat.sv());
          break;
        case ALLTYPE_ALLOCED_S:
          dbr.add((*cms).second.first, bat.s());
          break;
        case ALLTYPE_ALLOCED_M:
          dbr.add((*cms).second.first, bat.m());
          break;
        case ALLTYPE_ALLOCED_NM:
          dbr.add((*cms).second.first, bat.nm());
          break;
        case ALLTYPE_ALLOCED_IM:
          dbr.add((*cms).second.first, bat.im());
          break;
        case ALLTYPE_ALLOCED_SM:
          dbr.add((*cms).second.first, bat.sm());
          break;
#if 0
        case ALLTYPE_ALLOCED_X:
          dbr.add((*cms).second.first, bat.x());
          break;
        case ALLTYPE_ALLOCED_Y:
          dbr.add((*cms).second.first, bat.nx());
          break;
        case ALLTYPE_ALLOCED_XM:
          dbr.add((*cms).second.first, bat.xm());
          break;
#endif
      }
    }

    if(add_ds)
      /* get the deltas and certificates */
      ier.getd(*add_ds, *add_cs, thresh);
  }

  bool init_columns(vdbl::standard_table& stable)
  {
    bool ret(false);
    std::map<std::triple<std::string,bool,int>,
                      std::pair<std::string,basic_alltype> >::const_iterator cms;

    for(cms = info_to_col.begin(); cms != info_to_col.end(); ++cms)
    {
      switch((*cms).second.second.contents_type())
      {
        case ALLTYPE_INTERVAL:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.ni()) || ret;
          break;
        case ALLTYPE_DOUBLE:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.nd()) || ret;
          break;
        case ALLTYPE_UINT:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.nu()) || ret;
          break;
        case ALLTYPE_INT:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.nn()) || ret;
          break;
        case ALLTYPE_BOOL:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.nb()) || ret;
          break;
        case ALLTYPE_EMPTY:
          throw api_exception(apiee_search_graph,
              std::string("inference_engine_hook: in column ")+
              (*cms).second.first+", info name: "+(*cms).first.first+
              "default value is empty.");
          break;
        case ALLTYPE_ALLOCED_B:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.b()) || ret;
          break;
        case ALLTYPE_ALLOCED_N:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.n()) || ret;
          break;
        case ALLTYPE_ALLOCED_U:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.u()) || ret;
          break;
        case ALLTYPE_ALLOCED_D:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.d()) || ret;
          break;
        case ALLTYPE_ALLOCED_I:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.i()) || ret;
          break;
        case ALLTYPE_ALLOCED_C:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.sv()) || ret;
          break;
        case ALLTYPE_ALLOCED_S:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.s()) || ret;
          break;
        case ALLTYPE_ALLOCED_M:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.m()) || ret;
          break;
        case ALLTYPE_ALLOCED_NM:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.nm()) || ret;
          break;
        case ALLTYPE_ALLOCED_IM:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.im()) || ret;
          break;
        case ALLTYPE_ALLOCED_SM:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.sm()) || ret;
          break;
#if 0
        case ALLTYPE_ALLOCED_X:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.x()) || ret;
          break;
        case ALLTYPE_ALLOCED_Y:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.nx()) || ret;
          break;
        case ALLTYPE_ALLOCED_XM:
          ret = _init_column(stable, (*cms).second.first,
                                (*cms).second.second.xm()) || ret;
          break;
#endif
      }
    }
    return ret;
  }

  bool drop_columns(vdbl::standard_table& stable)
        { return _drop_columns(stable); }
};

} // namespace coco

#endif // _INFENG_HOOK_H

---