/*
 * Copyright © 2005-2011 Ondra Kamenik
 * Copyright © 2019 Dynare Team
 *
 * This file is part of Dynare.
 *
 * Dynare is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Dynare 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 General Public License
 * along with Dynare.  If not, see <https://www.gnu.org/licenses/>.
 */

#include "utils/cc/exception.hh"

#include "tree.hh"

#include <cmath>
#include <limits>
#include <sstream>
#include <iomanip>

using namespace ogp;

/** Here we initialize OperationTree to contain only zero, one, nan
 * and two_over_pi terms. */
OperationTree::OperationTree()
{
  last_nulary = -1;
  // allocate space for the constants
  for (int i = 0; i < num_constants; i++)
    add_nulary();
}

int
OperationTree::add_nulary()
{
  int op = terms.size();
  terms.push_back({});
  _Tintset s;
  s.insert(op);
  nul_incidence.push_back(s);
  derivatives.push_back({});
  last_nulary = op;
  return op;
}

int
OperationTree::add_unary(code_t code, int op)
{
  if (op == zero
      && (code == code_t::UMINUS
          || code == code_t::SIN
          || code == code_t::TAN
          || code == code_t::SQRT
          || code == code_t::ERF))
    return zero;
  if ((op == zero && code == code_t::LOG) || op == nan)
    return nan;
  if (op == zero && (code == code_t::EXP
                     || code == code_t::COS
                     || code == code_t::ERFC))
    return one;

  Operation unary(code, op);
  auto i = opmap.find(unary);
  if (i == opmap.end())
    {
      int newop = terms.size();
      // add to the terms
      terms.push_back(unary);
      // copy incidence of the operand
      nul_incidence.push_back(nul_incidence[op]);
      // insert it to opmap
      opmap.emplace(unary, newop);
      // add empty map of derivatives
      _Tderivmap empty;
      derivatives.push_back(empty);
      return newop;
    }
  return i->second;
}

int
OperationTree::add_binary(code_t code, int op1, int op2)
{
  // quick exits for special values
  if (op1 == nan || op2 == nan)
    return nan;
  // for plus
  if (code == code_t::PLUS)
    {
      if (op1 == zero && op2 == zero)
        return zero;
      else if (op1 == zero)
        return op2;
      else if (op2 == zero)
        return op1;
    }
  // for minus
  if (code == code_t::MINUS)
    {
      if (op1 == zero && op2 == zero)
        return zero;
      else if (op1 == zero)
        return add_unary(code_t::UMINUS, op2);
      else if (op2 == zero)
        return op1;
    }
  // for times
  if (code == code_t::TIMES)
    {
      if (op1 == zero || op2 == zero)
        return zero;
      else if (op1 == one)
        return op2;
      else if (op2 == one)
        return op1;
    }
  // for divide
  if (code == code_t::DIVIDE)
    {
      if (op1 == op2)
        return one;
      else if (op1 == zero)
        return zero;
      else if (op2 == zero)
        return nan;
    }
  // for power
  if (code == code_t::POWER)
    {
      if (op1 == zero && op2 == zero)
        return nan;
      else if (op1 == zero)
        return zero;
      else if (op2 == zero)
        return one;
      else if (op1 == one)
        return one;
      else if (op2 == one)
        return op1;
    }

  // order operands of commutative operations
  if (code == code_t::TIMES || code == code_t::PLUS)
    if (op1 > op2)
      {
        int tmp = op1;
        op1 = op2;
        op2 = tmp;
      }

  // construct operation and check/add it
  Operation binary(code, op1, op2);
  auto i = opmap.find(binary);
  if (i == opmap.end())
    {
      int newop = terms.size();
      terms.push_back(binary);
      // sum both sets of incidenting nulary operations
      nul_incidence.push_back(nul_incidence[op1]);
      nul_incidence.back().insert(nul_incidence[op2].begin(), nul_incidence[op2].end());
      // add to opmap
      opmap.emplace(binary, newop);
      // add empty map of derivatives
      _Tderivmap empty;
      derivatives.push_back(empty);
      return newop;
    }
  return i->second;
}

int
OperationTree::add_derivative(int t, int v)
{
  if (t < 0 || t >= static_cast<int>(terms.size()))
    throw ogu::Exception(__FILE__, __LINE__,
                         "Wrong value for tree index in OperationTree::add_derivative");

  // quick returns for nulary terms or empty incidence
  if (terms[t].nary() == 0 && t != v)
    return zero;

  if (terms[t].nary() == 0 && t == v)
    return one;

  if (nul_incidence[t].end() == nul_incidence[t].find(v))
    return zero;

  // quick return if the derivative has been registered
  auto i = derivatives[t].find(v);
  if (i != derivatives[t].end())
    return i->second;

  int res = -1;
  switch (terms[t].getCode())
    {
    case code_t::UMINUS:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        res = add_unary(code_t::UMINUS, tmp);
        break;
      }
    case code_t::LOG:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        res = add_binary(code_t::DIVIDE, tmp, terms[t].getOp1());
        break;
      }
    case code_t::EXP:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        res = add_binary(code_t::TIMES, t, tmp);
        break;
      }
    case code_t::SIN:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        res = add_binary(code_t::TIMES, add_unary(code_t::COS, terms[t].getOp1()), tmp);
        break;
      }
    case code_t::COS:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        res = add_unary(code_t::UMINUS, add_binary(code_t::TIMES, add_unary(code_t::SIN, terms[t].getOp1()), tmp));
        break;
      }
    case code_t::TAN:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        int tmp2 = add_unary(code_t::COS, terms[t].getOp1());
        res = add_binary(code_t::DIVIDE, tmp, add_binary(code_t::TIMES, tmp2, tmp2));
        break;
      }
    case code_t::SQRT:
      {
        int tmp = add_derivative(terms[t].getOp1(), v);
        res = add_binary(code_t::DIVIDE, tmp,
                         add_binary(code_t::PLUS, t, t));
        break;
      }
    case code_t::ERF:
      {
        int tmp = add_binary(code_t::TIMES, terms[t].getOp1(), terms[t].getOp1());
        tmp = add_unary(code_t::UMINUS, tmp);
        tmp = add_unary(code_t::EXP, tmp);
        int der = add_derivative(terms[t].getOp1(), v);
        tmp = add_binary(code_t::TIMES, tmp, der);
        res = add_binary(code_t::TIMES, two_over_pi, tmp);
        break;
      }
    case code_t::ERFC:
      {
        int tmp = add_binary(code_t::TIMES, terms[t].getOp1(), terms[t].getOp1());
        tmp = add_unary(code_t::UMINUS, tmp);
        tmp = add_unary(code_t::EXP, tmp);
        int der = add_derivative(terms[t].getOp1(), v);
        tmp = add_binary(code_t::TIMES, tmp, der);
        tmp = add_binary(code_t::TIMES, two_over_pi, tmp);
        res = add_unary(code_t::UMINUS, tmp);
        break;
      }
    case code_t::PLUS:
      {
        int tmp1 = add_derivative(terms[t].getOp1(), v);
        int tmp2 = add_derivative(terms[t].getOp2(), v);
        res = add_binary(code_t::PLUS, tmp1, tmp2);
        break;
      }
    case code_t::MINUS:
      {
        int tmp1 = add_derivative(terms[t].getOp1(), v);
        int tmp2 = add_derivative(terms[t].getOp2(), v);
        res = add_binary(code_t::MINUS, tmp1, tmp2);
        break;
      }
    case code_t::TIMES:
      {
        int tmp1 = add_derivative(terms[t].getOp1(), v);
        int tmp2 = add_derivative(terms[t].getOp2(), v);
        int res1 = add_binary(code_t::TIMES, terms[t].getOp1(), tmp2);
        int res2 = add_binary(code_t::TIMES, tmp1, terms[t].getOp2());
        res = add_binary(code_t::PLUS, res1, res2);
        break;
      }
    case code_t::DIVIDE:
      {
        int tmp1 = add_derivative(terms[t].getOp1(), v);
        int tmp2 = add_derivative(terms[t].getOp2(), v);
        if (tmp2 == zero)
          res = add_binary(code_t::DIVIDE, tmp1, terms[t].getOp2());
        else
          {
            int nom = add_binary(code_t::MINUS,
                                 add_binary(code_t::TIMES, tmp1, terms[t].getOp2()),
                                 add_binary(code_t::TIMES, tmp2, terms[t].getOp1()));
            int den = add_binary(code_t::TIMES, terms[t].getOp2(), terms[t].getOp2());
            res = add_binary(code_t::DIVIDE, nom, den);
          }
        break;
      }
    case code_t::POWER:
      {
        int tmp1 = add_derivative(terms[t].getOp1(), v);
        int tmp2 = add_derivative(terms[t].getOp2(), v);
        int s1 = add_binary(code_t::TIMES, tmp2,
                            add_binary(code_t::TIMES, t,
                                       add_unary(code_t::LOG, terms[t].getOp1())));
        int s2 = add_binary(code_t::TIMES, tmp1,
                            add_binary(code_t::TIMES, terms[t].getOp2(),
                                       add_binary(code_t::POWER, terms[t].getOp1(),
                                                  add_binary(code_t::MINUS, terms[t].getOp2(), one))));
        res = add_binary(code_t::PLUS, s1, s2);
        break;
      }
    case code_t::NONE:
      break;
    }

  if (res == -1)
    throw ogu::Exception(__FILE__, __LINE__,
                         "Unknown operation code.");

  register_derivative(t, v, res);

  return res;
}

int
OperationTree::add_substitution(int t, const map<int, int> &subst)
{
  return add_substitution(t, subst, *this);
}

int
OperationTree::add_substitution(int t, const map<int, int> &subst,
                                const OperationTree &otree)
{
  // return substitution of t if it is in the map
  auto it = subst.find(t);
  if (subst.end() != it)
    return it->second;

  int nary = otree.terms[t].nary();
  if (nary == 2)
    {
      // return the binary operation of the substituted terms
      int t1 = add_substitution(otree.terms[t].getOp1(), subst, otree);
      int t2 = add_substitution(otree.terms[t].getOp2(), subst, otree);
      return add_binary(otree.terms[t].getCode(), t1, t2);
    }
  else if (nary == 1)
    {
      // return the unary operation of the substituted term
      int t1 = add_substitution(otree.terms[t].getOp1(), subst, otree);
      return add_unary(otree.terms[t].getCode(), t1);
    }
  else
    {
      // if t is not the first num_constants, and otree is not this
      // tree, then raise and exception. Otherwise return t, since
      // it is either a special term (having the same semantics in
      // both trees), or the trees are the same, hence t has the
      // same semantics
      if (t < num_constants || this == &otree)
        return t;
      else
        {
          throw ogu::Exception(__FILE__, __LINE__,
                               "Incomplete substitution map in OperationTree::add_substitution");
          return -1;
        }
    }
}

void
OperationTree::nularify(int t)
{
  // remove the original operation from opmap
  auto it = opmap.find(terms[t]);
  if (it != opmap.end())
    opmap.erase(it);
  // turn the operation to nulary
  Operation nulary_op;
  terms[t] = nulary_op;
  // update last nulary
  if (last_nulary < t)
    last_nulary = t;
  // update nul_incidence information for all terms including t
  update_nul_incidence_after_nularify(t);
}

void
OperationTree::register_derivative(int t, int v, int tder)
{
  // todo: might check that the insert inserts a new pair
  derivatives[t].emplace(v, tder);
}

unordered_set<int>
OperationTree::select_terms(int t, const opselector &sel) const
{
  unordered_set<int> subterms;
  select_terms(t, sel, subterms);
  return subterms;
}

void
OperationTree::select_terms(int t, const opselector &sel, unordered_set<int> &subterms) const
{
  const Operation &op = terms[t];

  if (sel(t))
    subterms.insert(t);
  else
    if (op.nary() == 2)
      {
        select_terms(op.getOp1(), sel, subterms);
        select_terms(op.getOp2(), sel, subterms);
      }
    else if (op.nary() == 1)
      select_terms(op.getOp1(), sel, subterms);
}

unordered_set<int>
OperationTree::select_terms_inv(int t, const opselector &sel) const
{
  unordered_set<int> subterms;
  select_terms_inv(t, sel, subterms);
  return subterms;
}

bool
OperationTree::select_terms_inv(int t, const opselector &sel, unordered_set<int> &subterms) const
{
  const Operation &op = terms[t];

  if (op.nary() == 2)
    {
      bool a1 = select_terms_inv(op.getOp1(), sel, subterms);
      bool a2 = select_terms_inv(op.getOp2(), sel, subterms);
      if (a1 && a2 && sel(t))
        {
          subterms.insert(t);
          return true;
        }
    }
  else if (op.nary() == 1)
    {
      bool a1 = select_terms_inv(op.getOp1(), sel, subterms);
      if (a1 && sel(t))
        {
          subterms.insert(t);
          return true;
        }
    }
  else
    {
      if (sel(t))
        {
          subterms.insert(t);
          return true;
        }
    }

  return false;
}

void
OperationTree::forget_derivative_maps()
{
  for (auto &derivative : derivatives)
    derivative.clear();
}

void
OperationTree::print_operation_tree(int t, std::ostream &os, OperationFormatter &f) const
{
  f.format(terms[t], t, os);
}

void
OperationTree::print_operation(int t) const
{
  DefaultOperationFormatter dof(*this);
  print_operation_tree(t, std::cout, dof);
}

void
OperationTree::update_nul_incidence_after_nularify(int t)
{
  unordered_set<int> updated;
  for (int tnode = num_constants; tnode < static_cast<int>(terms.size()); tnode++)
    {
      const Operation &op = terms[tnode];
      if (op.nary() == 2)
        {
          int op1 = op.getOp1();
          int op2 = op.getOp2();
          if (op1 >= tnode || op2 >= tnode)
            throw ogu::Exception(__FILE__, __LINE__,
                                 "Tree disorder asserted");
          bool updated1 = (updated.end() != updated.find(op1));
          bool updated2 = (updated.end() != updated.find(op2));
          if (updated1 || updated2)
            {
              nul_incidence[tnode] = nul_incidence[op1];
              nul_incidence[tnode].insert(nul_incidence[op2].begin(), nul_incidence[op2].end());
              updated.insert(tnode);
            }
        }
      else if (op.nary() == 1)
        {
          int op1 = op.getOp1();
          if (op1 >= tnode)
            throw ogu::Exception(__FILE__, __LINE__,
                                 "Tree disorder asserted");
          bool updated1 = (updated.end() != updated.find(op1));
          if (updated1)
            {
              nul_incidence[tnode] = nul_incidence[op1];
              updated.insert(tnode);
            }
        }
      else if (op.nary() == 0)
        {
          if (tnode == t)
            {
              nul_incidence[tnode].clear();
              nul_incidence[tnode].insert(tnode);
              updated.insert(tnode);
            }
        }
    }
}

EvalTree::EvalTree(const OperationTree &ot, int last)
  : otree(ot),
    values(std::make_unique<double[]>((last == -1) ? ot.terms.size() : last+1)),
    flags(std::make_unique<bool[]>((last == -1) ? ot.terms.size() : last+1)),
    last_operation((last == -1) ? ot.terms.size()-1 : last)
{
  if (last_operation < OperationTree::num_constants-1
      || last_operation > static_cast<int>(ot.terms.size())-1)
    throw ogu::Exception(__FILE__, __LINE__,
                         "Wrong last in EvalTree constructor.");

  values[0] = 0.0;
  flags[0] = true;
  values[1] = 1.0;
  flags[1] = true;
  values[2] = std::numeric_limits<double>::quiet_NaN();
  flags[2] = true;
  values[3] = 2.0/std::sqrt(M_PI);
  flags[3] = true;
  // this sets from num_constants on
  reset_all();
}

void
EvalTree::reset_all()
{
  for (int i = OperationTree::num_constants; i <= last_operation; i++)
    flags[i] = false;
}

void
EvalTree::set_nulary(int t, double val)
{
  if (t < 0 || t > last_operation)
    throw ogu::Exception(__FILE__, __LINE__,
                         "The tree index out of bounds in EvalTree::set_nulary");
  if (t < OperationTree::num_constants || otree.terms[t].nary() != 0)
    throw ogu::Exception(__FILE__, __LINE__,
                         "The term is not nulary assignable in EvalTree::set_nulary");

  values[t] = val;
  flags[t] = true;
}

double
EvalTree::eval(int t)
{
  if (t < 0 || t > last_operation)
    throw ogu::Exception(__FILE__, __LINE__,
                         "The tree index out of bounds in EvalTree::eval");
  if (otree.terms[t].nary() == 0 && flags[t] == false)
    throw ogu::Exception(__FILE__, __LINE__,
                         "Nulary term has not been assigned a value in EvalTree::eval");

  if (!flags[t])
    {
      const Operation &op = otree.terms[t];
      if (op.nary() == 1)
        {
          double r1 = eval(op.getOp1());
          double res;
          if (op.getCode() == code_t::UMINUS)
            res = -r1;
          else if (op.getCode() == code_t::LOG)
            res = log(r1);
          else if (op.getCode() == code_t::EXP)
            res = exp(r1);
          else if (op.getCode() == code_t::SIN)
            res = sin(r1);
          else if (op.getCode() == code_t::COS)
            res = cos(r1);
          else if (op.getCode() == code_t::TAN)
            res = tan(r1);
          else if (op.getCode() == code_t::SQRT)
            res = sqrt(r1);
          else if (op.getCode() == code_t::ERF)
            res = erf(r1);
          else if (op.getCode() == code_t::ERFC)
            res = erfc(r1);
          else
            {
              throw ogu::Exception(__FILE__, __LINE__,
                                   "Unknown unary operation code in EvalTree::eval");
              res = 0.0;
            }
          values[t] = res;
          flags[t] = true;
        }
      else if (op.nary() == 2)
        {
          double res;
          if (op.getCode() == code_t::PLUS)
            {
              double r1 = eval(op.getOp1());
              double r2 = eval(op.getOp2());
              res = r1 + r2;
            }
          else if (op.getCode() == code_t::MINUS)
            {
              double r1 = eval(op.getOp1());
              double r2 = eval(op.getOp2());
              res = r1 - r2;
            }
          else if (op.getCode() == code_t::TIMES)
            {
              // pickup less complex formula first
              unsigned int nul1 = otree.nulary_of_term(op.getOp1()).size();
              unsigned int nul2 = otree.nulary_of_term(op.getOp2()).size();
              if (nul1 < nul2)
                {
                  double r1 = eval(op.getOp1());
                  if (r1 == 0.0)
                    res = 0.0;
                  else
                    {
                      double r2 = eval(op.getOp2());
                      res = r1 * r2;
                    }
                }
              else
                {
                  double r2 = eval(op.getOp2());
                  if (r2 == 0)
                    res = 0.0;
                  else
                    {
                      double r1 = eval(op.getOp1());
                      res = r1*r2;
                    }
                }
            }
          else if (op.getCode() == code_t::DIVIDE)
            {
              double r1 = eval(op.getOp1());
              if (r1 == 0)
                res = 0.0;
              else
                {
                  double r2 = eval(op.getOp2());
                  res = r1 / r2;
                }
            }
          else if (op.getCode() == code_t::POWER)
            {
              // suppose that more complex is the first op in average
              double r2 = eval(op.getOp2());
              if (r2 == 0.0)
                res = 1.0;
              else
                {
                  double r1 = eval(op.getOp1());
                  res = pow(r1, r2);
                }
            }
          else
            {
              throw ogu::Exception(__FILE__, __LINE__,
                                   "Unknown binary operation code in EvalTree::eval");
              res = 0.0;
            }
          values[t] = res;
          flags[t] = true;
        }
      return values[t];
    }

  return values[t];
}

void
EvalTree::print() const
{
  std::cout <<   "last_op=" << last_operation << '\n'
            <<   "         0     1     2     3     4     5     6     7     8     9\n"
            << u8"────────────────────────────────────────────────────────────────\n";
  for (int i = 0; i <= (last_operation+1)/10; i++)
    {
      std::cout << std::setw(3) << i << u8"│";
      int j = 0;
      while (j < 10 && 10*i+j < last_operation+1)
        {
          int k = 10*i+j;
          if (flags[k])
            std::cout << " " << std::setw(5) << std::setprecision(1) << values[k];
          else
            std::cout << u8" ─────";
          j++;
        }
      std::cout << "\n";
    }
}

void
DefaultOperationFormatter::format(const Operation &op, int t, std::ostream &os)
{
  // add to the stop_set
  if (stop_set.end() == stop_set.find(t))
    stop_set.insert(t);
  else
    return;

  // call recursively non-nulary terms of the operation
  if (op.nary() == 2)
    {
      int t1 = op.getOp1();
      const Operation &op1 = otree.terms[t1];
      int t2 = op.getOp2();
      const Operation &op2 = otree.terms[t2];
      if (op1.nary() > 0)
        format(op1, t1, os);
      if (op2.nary() > 0)
        format(op2, t2, os);
    }
  if (op.nary() == 1)
    {
      int t1 = op.getOp1();
      const Operation &op1 = otree.terms[t1];
      if (op1.nary() > 0)
        format(op1, t1, os);
    }

  // print 'term ='
  format_term(t, os);
  os << " = ";
  if (op.nary() == 0)
    format_nulary(t, os);
  else if (op.nary() == 1)
    {
      int t1 = op.getOp1();
      const Operation &op1 = otree.terms[t1];
      std::string opname = "unknown";
      switch (op.getCode())
        {
        case code_t::UMINUS:
          opname = "-";
          break;
        case code_t::LOG:
          opname = "log";
          break;
        case code_t::EXP:
          opname = "exp";
          break;
        case code_t::SIN:
          opname = "sin";
          break;
        case code_t::COS:
          opname = "cos";
          break;
        case code_t::TAN:
          opname = "tan";
          break;
        case code_t::SQRT:
          opname = "sqrt";
          break;
        case code_t::ERF:
          opname = "erf";
          break;
        case code_t::ERFC:
          opname = "erfc";
          break;
        default:
          break;
        }
      os << opname << '(';
      if (op1.nary() == 0)
        format_nulary(t1, os);
      else
        format_term(t1, os);
      os << ")";
    }
  else
    {
      int t1 = op.getOp1();
      const Operation &op1 = otree.terms[t1];
      int t2 = op.getOp2();
      const Operation &op2 = otree.terms[t2];
      std::string opname = "unknown";
      switch (op.getCode())
        {
        case code_t::PLUS:
          opname = "+";
          break;
        case code_t::MINUS:
          opname = "-";
          break;
        case code_t::TIMES:
          opname = "*";
          break;
        case code_t::DIVIDE:
          opname = "/";
          break;
        case code_t::POWER:
          opname = "^";
          break;
        default:
          break;
        }
      if (op1.nary() == 0)
        format_nulary(t1, os);
      else
        format_term(t1, os);
      os << ' ' << opname << ' ';
      if (op2.nary() == 0)
        format_nulary(t2, os);
      else
        format_term(t2, os);
    }

  print_delim(os);
}

void
DefaultOperationFormatter::format_term(int t, std::ostream &os) const
{
  os << '$' << t;
}

void
DefaultOperationFormatter::format_nulary(int t, std::ostream &os) const
{
  if (t == OperationTree::zero)
    os << '0';
  else if (t == OperationTree::one)
    os << '1';
  else if (t == OperationTree::nan)
    os << "NaN";
  else
    os << '$' << t;
}

void
DefaultOperationFormatter::print_delim(std::ostream &os) const
{
  os << ";\n";
}

std::string
OperationStringConvertor::convert(const Operation &op, int t) const
{
  if (op.nary() == 0)
    {
      if (t < OperationTree::num_constants)
        if (t == OperationTree::zero)
          return "0";
        else if (t == OperationTree::one)
          return "1";
        else if (t == OperationTree::nan)
          return "NaN";
        else if (t == OperationTree::two_over_pi)
          {
            std::ostringstream buf;
            buf << std::setprecision(std::numeric_limits<double>::max_digits10)
                << 2.0/std::sqrt(M_PI);
            return buf.str();
          }
        else
          return "error!error";
      else
        return nulsc.convert(t);
    }
  else if (op.nary() == 1)
    {
      int t1 = op.getOp1();
      const Operation &op1 = otree.operation(t1);
      std::string opname = "unknown";
      switch (op.getCode())
        {
        case code_t::UMINUS:
          opname = "-";
          break;
        case code_t::LOG:
          opname = "log";
          break;
        case code_t::EXP:
          opname = "exp";
          break;
        case code_t::SIN:
          opname = "sin";
          break;
        case code_t::COS:
          opname = "cos";
          break;
        case code_t::TAN:
          opname = "tan";
          break;
        case code_t::SQRT:
          opname = "sqrt";
          break;
        case code_t::ERF:
          opname = "erf";
          break;
        case code_t::ERFC:
          opname = "erfc";
          break;
        default:
          break;
        }
      std::string s1 = convert(op1, t1);
      return opname + "(" + s1 + ")";
    }
  else
    {
      int t1 = op.getOp1();
      const Operation &op1 = otree.operation(t1);
      int t2 = op.getOp2();
      const Operation &op2 = otree.operation(t2);
      std::string opname = "unknown";
      switch (op.getCode())
        {
        case code_t::PLUS:
          opname = "+";
          break;
        case code_t::MINUS:
          opname = "-";
          break;
        case code_t::TIMES:
          opname = "*";
          break;
        case code_t::DIVIDE:
          opname = "/";
          break;
        case code_t::POWER:
          opname = "^";
          break;
        default:
          break;
        }
      // decide about parenthesis
      bool op1_par = true;
      bool op2_par = true;
      if (op.getCode() == code_t::PLUS)
        {
          op1_par = false;
          op2_par = false;
        }
      else if (op.getCode() == code_t::MINUS)
        {
          op1_par = false;
          if (op2.getCode() != code_t::MINUS && op2.getCode() != code_t::PLUS)
            op2_par = false;
        }
      else
        {
          if (op1.nary() < 2)
            op1_par = false;
          if (op2.nary() < 2)
            op2_par = false;
        }

      std::string res;
      if (op1_par)
        res += "(";
      res += convert(op1, t1);
      if (op1_par)
        res += ")";
      res += " ";
      res += opname;
      res += " ";
      if (op2_par)
        res += "(";
      res += convert(op2, t2);
      if (op2_par)
        res += ")";

      return res;
    }
}