expression.hpp

Go to the documentation of this file.

// Expression implementation -*- C++ -*-

// $Id: expression.hpp 347 2008-02-06 15:20:01Z schilly $
// Copyright (C) 2001-2003 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 _EXPRESSION_HPP_
#define _EXPRESSION_HPP_

#include <api_exception.h>

namespace coco {

class expression_node::parents_compare :
      public std::binary_function<expression_node, expression_node, bool>
{
public:
  bool operator()(const expression_node& __x, const expression_node& __y)
  const
  {
    if(__x.operator_type == __y.operator_type)
    {
      switch(__x.operator_type)
      {
        case EXPRINFO_GHOST:
          if(__x.node_num != __y.node_num)
            return __x.node_num < __y.node_num;
          break;
        case EXPRINFO_VARIABLE:
          if(__x.params.nn() != __y.params.nn())
            return __x.params.nn() < __y.params.nn();
          break;
        case EXPRINFO_CONSTANT:
          if(__x.params.is_allocated() != __y.params.is_allocated())
            return __x.params.is_allocated() < __y.params.is_allocated();
          if(__x.params.is_allocated())
          {
            if(__x.params.d() != __y.params.d())
              return __x.params.d() < __y.params.d();
          }
          else
          {
            if(__x.params.nd() != __y.params.nd())
              return __x.params.nd() < __y.params.nd();
          }
          break;
      }
      if(__x.n_children == __y.n_children)
        return __x.node_num < __y.node_num;
      return __x.n_children < __y.n_children;
    }
    return __x.operator_type < __y.operator_type;
  }
};

class expression_node::children_compare :
      public std::binary_function<expression_node, expression_node, bool>
{
public:
  bool operator()(const expression_node& __x, const expression_node& __y)
  const
  {
    if(__x.sem.degree != __y.sem.degree)
      return __x.sem.degree < __y.sem.degree;
    if(__x.sem.dim != __y.sem.dim)
      return __x.sem.dim < __y.sem.dim;
    if(__x.operator_type == __y.operator_type)
    {
      switch(__x.operator_type)
      {
        case EXPRINFO_GHOST:
          if(__x.node_num != __y.node_num)
            return __x.node_num < __y.node_num;
          break;
        case EXPRINFO_VARIABLE:
          if(__x.params.nn() != __y.params.nn())
            return __x.params.nn() < __y.params.nn();
          break;
        case EXPRINFO_CONSTANT:
          if(__x.params.is_allocated() != __y.params.is_allocated())
            return __x.params.is_allocated() < __y.params.is_allocated();
          if(__x.params.is_allocated())
          {
            if(__x.params.d() != __y.params.d())
              return __x.params.d() < __y.params.d();
          }
          else
          {
            if(__x.params.nd() != __y.params.nd())
              return __x.params.nd() < __y.params.nd();
          }
          break;
      }
      if(__x.n_children == __y.n_children)
        return __x.node_num < __y.node_num;
      return __x.n_children < __y.n_children;
    }
    return __x.operator_type < __y.operator_type;
  }
};

class expression_node::parents_compare_eq :
      public std::binary_function<expression_node, expression_node, bool>
{
public:
  bool operator()(const expression_node& __x, const expression_node& __y)
  const
  {
    if(__x.n_children != __y.n_children)
      return false;
    if(__x.operator_type == __y.operator_type)
    {
      switch(__x.operator_type)
      {
        case EXPRINFO_GHOST:
          return __x.node_num == __y.node_num;
          break;
        case EXPRINFO_VARIABLE:
          return __x.params.nn() == __y.params.nn();
          break;
        case EXPRINFO_CONSTANT:
          if(__x.params.is_allocated() != __y.params.is_allocated())
            return false;
          if(__x.params.is_allocated())
            return __x.params.d() == __y.params.d();
          else
            return __x.params.nd() == __y.params.nd();
          break;
        case EXPRINFO_SUM:
        case EXPRINFO_MAX:
        case EXPRINFO_MIN:
        case EXPRINFO_SQUARE:
        case EXPRINFO_SQROOT:
        case EXPRINFO_ABS:
        case EXPRINFO_POW:
        case EXPRINFO_EXP:
        case EXPRINFO_LOG:
        case EXPRINFO_SIN:
        case EXPRINFO_COS:
          if(__x.params.nd() != __y.params.nd())
            return false;
          /* no break! */
        case EXPRINFO_ATAN2:
          {
            std::vector<double>::const_iterator _bx, _by;

            for(_bx = __x.coeffs.begin(), _by = __y.coeffs.begin();
                _bx != __x.coeffs.end(); ++_bx, ++_by)
            {
              if(*_bx != *_by) return false;
            }
          }
          break;
        case EXPRINFO_PROD:
        case EXPRINFO_INVERT:
        case EXPRINFO_DIV:
          if(__x.params.nd() != __y.params.nd())
            return false;
          break;
        case EXPRINFO_INTPOWER:
          if(__x.params.nn() != __y.params.nn() ||
             __x.coeffs[0] != __y.coeffs[0])
            return false;
          break;
        case EXPRINFO_GAUSS:
          if(__x.params.d()[0] != __y.params.d()[0] ||
             __x.params.d()[1] != __y.params.d()[1] ||
             __x.coeffs[0] != __y.coeffs[0])
            return false;
          break;
        case EXPRINFO_POLY:
          throw nyi_exception("expression_node::parents_compare_eq: POLY");
          break;
        case EXPRINFO_LIN:
        case EXPRINFO_QUAD:
          return false;
        default:
          throw api_exception(apiee_internal,
              std::string("expression_node::parents_compare_eq: unknown function type ")+convert_to_str(__x.operator_type));
          return false;
          break;
      }
      return true;
    }
    return false;
  }
};
  
inline bool expression_node::operator<(const expression_node& __x) const
{
  return this->node_num < __x.node_num;
}

class expression_print_visitor : public preorder_visitor<expression_node, int>
{
  int n;
  int nnum;
  std::ostream& o;
  std::vector<bool>* printed;
public:
  expression_print_visitor(std::vector<bool>& __p, std::ostream& __o = std::cout)
    : o(__o)
    { printed = &__p; }
  expression_print_visitor(const expression_print_visitor& __p) : o(__p.o)
     { n = __p.n; nnum = __p.nnum; printed = __p.printed; }
  ~expression_print_visitor() {}


  bool preorder(const expression_node &r)
        { n = 0;
          nnum = r.node_num;
          if((int)(*printed).size() <= nnum)
            (*printed).insert((*printed).end(), nnum - (*printed).size()+1,
                              false);
          if(!(*printed)[nnum])
          {
            (*printed)[nnum] = true;
            o << r;
          }
          else /* a node has to be walked only once */
            return false;
          return true;
        }
  int vvalue() { return -1; }
  int value() { return nnum; }
  void collect(const expression_node &r, int __r)
         { 
           if(__r >= 0)
           {
             o << "<E> " << r.node_num << ' ' << __r << ' ' <<
               r.coeffs[n] << std::endl;
             n++;
           }
         }
};

inline std::ostream& __wr_interval(std::ostream& o, const interval& __i)
{
  if(__i.inf() != -COCO_INF || __i.sup() != COCO_INF)
  {
    o << "[";
    if(__i.inf() == -COCO_INF)
      o << "-I";
    else
      o << __i.inf();
    o << ",";
      if(__i.sup() == COCO_INF)
    o << "I";
      else
    o << __i.sup();
    o << "]";
  }
  return o;
}

} // namespace coco

#endif /* _EXPRESSION_HPP_ */

---