field_nonlinear_expr.h

Go to the documentation of this file.

#ifndef _RHEOLEF_FIELD_EXPR_NONLINEAR_H
#define _RHEOLEF_FIELD_EXPR_NONLINEAR_H
#include "rheolef/field_evaluate.h"
#include "rheolef/tensor4.h"

#include <boost/functional.hpp>

namespace rheolef {
namespace detail {
 struct has_local_evaluate_member {};
} // namespace detail

template<class Function> class field_expr_terminal_function;

template<class Function>
field_expr_terminal_function<Function>
field_function (const Function& f)
{
  return field_expr_terminal_function<Function>(f);
}

template<class Function>
class field_expr_terminal_function_rep {
public:

  typedef geo_element::size_type                                size_type;
  typedef rheo_default_memory_model                             memory_type;
  typedef typename boost::unary_traits<Function>::function_type function_type;
  typedef typename boost::unary_traits<Function>::result_type   result_type;
  typedef typename scalar_traits<result_type>::type             scalar_type;
  typedef typename  float_traits<result_type>::type             float_type;
  typedef result_type                                           value_type;
  typedef quadrature<float_type>                                pointset; // TODO: extends


  field_expr_terminal_function_rep(const Function& f) 
    : _f(f),
      _is_initialized(false),
      _omega(),
      _piola_ops()
    {}


  static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<result_type>::value;

  space_constant::valued_type valued_tag() const {
      return space_constant::valued_tag_traits<result_type>::value; }

  void evaluate (const geo_element& K, std::vector<result_type>& value) const {
    check_macro (_is_initialized, "may be initialized");
    _omega.dis_inod (K, _dis_inod);
    reference_element hat_K = K.variant();
    value.resize (_piola_ops.size(hat_K));
    size_type q = 0;
    for (typename std::vector<result_type>::iterator
          iter = value.begin(),
          last = value.end(); iter != last; ++iter, ++q) {
      point_basic<float_type> xq = piola_transformation (_omega, _piola_ops, K, _dis_inod, q);
      *iter = _f (xq);
    }
  }
  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const {
    _omega = omega;
    _piola_ops.set (hat_x, omega.get_piola_basis());
    _is_initialized = true;
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
    _omega = Xh.get_geo();
    _piola_ops.set (Xh.get_numbering().get_basis(), _omega.get_piola_basis());
    _is_initialized = true;
    return true;
  }
protected:
  function_type                             _f;
  mutable bool                              _is_initialized;
  mutable geo_basic<float_type,memory_type> _omega;
  mutable basis_on_pointset<float_type>     _piola_ops;
  mutable std::vector<size_type>            _dis_inod;
};
template<class Function>
class field_expr_terminal_function
        : public detail::has_local_evaluate_member, 
          public smart_pointer<field_expr_terminal_function_rep<Function> >
{
public:

  typedef field_expr_terminal_function_rep<Function> rep;
  typedef smart_pointer<rep>                    base;
  typedef typename rep::size_type               size_type;
  typedef typename rep::memory_type             memory_type;
  typedef typename rep::result_type             result_type;
  typedef typename rep::value_type              value_type;
  typedef typename rep::scalar_type             scalar_type;
  typedef typename rep::float_type              float_type;
  typedef typename rep::pointset                pointset;
  static const space_constant::valued_type valued_hint = rep::valued_hint;


  field_expr_terminal_function(const Function& f) : base(new_macro(rep(f))) {} 


  space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }

  void evaluate (const geo_element& K, std::vector<result_type>& value) const {
        base::data().evaluate(K,value); }

  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const {
        base::data().initialize(omega,hat_x);
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
        return base::data().initialize(Xh);
  }
};
template<class T, class M>
class field_expr_terminal_field_rep {
public:

  typedef geo_element::size_type          size_type;
  typedef M                               memory_type;
  typedef undeterminated_basic<T>         result_type;
  typedef result_type                     value_type;
  typedef T                               scalar_type;
  typedef typename float_traits<T>::type  float_type;
  typedef quadrature<float_type>          pointset; // TODO: extends


  field_expr_terminal_field_rep(const field_basic<T,M>& uh) 
    : _uh(uh), _is_initialized(false), _bops(), _dis_idof() {}

  template <class Expr>
  explicit field_expr_terminal_field_rep(const field_expr<Expr>& expr) 
    : _uh(expr), _is_initialized(false), _bops(), _dis_idof() {}


  static const space_constant::valued_type valued_hint = space_constant::last_valued;

  space_constant::valued_type valued_tag() const { return _uh.valued_tag(); }

  template<class Result>
  void evaluate (const geo_element& K, std::vector<Result>& value) const {
    check_macro (_is_initialized, "may be initialized");
    _check<Result>(); // run-time check :-(
    reference_element hat_K = K.variant();
    value.resize (_bops.size(hat_K));
    _uh.get_space().dis_idof (K, _dis_idof);
    size_type q = 0;
    for (typename std::vector<Result>::iterator
        iter = value.begin(),
        last = value.end(); iter != last; ++iter, ++q) {
      generic_field_evaluate (_uh, _bops, hat_K, _dis_idof, q, *iter);
    }
  }
  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const {
    _bops.set (hat_x, _uh.get_space().get_numbering().get_basis());
    _uh.dis_dof_update();
    _is_initialized = true;
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
    _bops.set (Xh.get_numbering().get_basis(), _uh.get_space().get_numbering().get_basis());
    _uh.dis_dof_update();
    _is_initialized = true;
    return are_compatible (_uh.get_space(), Xh);
  }
protected:
  template<class Result>
  void _check () const {
    space_constant::valued_type result_valued_tag = space_constant::valued_tag_traits<Result>::value;
    check_macro (_uh.valued_tag() == result_valued_tag, "unexpected "<<_uh.valued()
        << "-valued field for " << space_constant::valued_name(result_valued_tag)
        << "-valued evaluator");
  }
  field_basic<T,M>                 _uh;
  mutable bool                     _is_initialized;
  mutable basis_on_pointset<T>     _bops;
  mutable std::vector<size_type>   _dis_idof;
};
template<class T, class M>
class field_expr_terminal_field
        : public detail::has_local_evaluate_member, 
          public smart_pointer<field_expr_terminal_field_rep<T,M> >
{
public:

  typedef field_expr_terminal_field_rep<T,M>    rep;
  typedef smart_pointer<rep>                    base;
  typedef typename rep::size_type               size_type;
  typedef typename rep::memory_type             memory_type;
  typedef typename rep::result_type             result_type;
  typedef typename rep::pointset                pointset;
  typedef typename rep::float_type              float_type;
  typedef typename rep::scalar_type             scalar_type;
  typedef typename rep::value_type              value_type;
  static const space_constant::valued_type valued_hint = rep::valued_hint;


  field_expr_terminal_field(const field_basic<T,M>& uh)
    : base(new_macro(rep(uh))) {} 

  template <class Expr>
  explicit field_expr_terminal_field(const field_expr<Expr>& expr) 
    : base(new_macro(rep(expr))) {} 


  space_constant::valued_type valued_tag() const { return base::data().valued_tag(); }

  template<class Result>
  void evaluate (const geo_element& K, std::vector<Result>& value) const {
        base::data().evaluate(K,value); }

  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const {
        base::data().initialize(omega,hat_x);
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
        return base::data().initialize(Xh);
  }
};
template<class RawExpr>
class field_nonlinear_expr : public detail::has_local_evaluate_member {
public:

  typedef geo_element::size_type         size_type;
  typedef typename RawExpr::memory_type  memory_type;
  typedef typename RawExpr::result_type  result_type;
  typedef typename RawExpr::value_type   value_type;
  typedef typename RawExpr::float_type   float_type;
  typedef typename RawExpr::scalar_type  scalar_type;
  typedef quadrature<float_type>         pointset; // TODO: extends


  field_nonlinear_expr (const RawExpr& raw_expr) 
    : _raw_expr(raw_expr) {}


  static const space_constant::valued_type valued_hint = RawExpr::valued_hint;

  space_constant::valued_type valued_tag() const { return _raw_expr.valued_tag(); }

  template<class Result>
  void evaluate (const geo_element& K, std::vector<Result>& value) const {
    _raw_expr.evaluate (K, value);
  }
  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const {
    _raw_expr.initialize (omega, hat_x);
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
    return _raw_expr.initialize (Xh);
  }

protected:
  RawExpr   _raw_expr;
};
template<class Function>
struct generic_unary_traits {
  template<class T>
  struct with {
    typedef typename boost::remove_const<
              typename boost::remove_reference<
                typename boost::unary_traits<Function>::argument_type>::type>::type
            argument_type;
    typedef typename boost::unary_traits<Function>::  result_type    result_type;
    typedef typename boost::unary_traits<Function>::function_type  function_type;
  };
  template <class Arg>
  struct result_hint {
    typedef typename boost::unary_traits<Function>::result_type type;
  };
  static space_constant::valued_type
  valued_tag (space_constant::valued_type) {
    return space_constant::valued_tag_traits<typename with<void>::result_type>::value;
  }
};
template<class Function, class Expr>
class field_nonlinear_expr_uf : public detail::has_local_evaluate_member {
public:

  typedef geo_element::size_type           size_type;
  typedef typename Expr::memory_type       memory_type;
  typedef typename generic_unary_traits<Function>::template result_hint<typename Expr::result_type>::type result_type;
  typedef Float                            float_type; // TODO
  typedef Float                            scalar_type; // TODO
  typedef quadrature<float_type>           pointset;
  typedef result_type                      value_type;


  field_nonlinear_expr_uf (const Function& f, const field_nonlinear_expr<Expr>& expr) 
    : _f(f), _expr(expr) {}


  static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<result_type>::value;

  space_constant::valued_type valued_tag() const {
    return generic_unary_traits<Function>::valued_tag(_expr.valued_tag());
  }


  template<class Result, class Arg>
  void evaluate_internal (const geo_element& K, std::vector<Result>& value) const {
    _check<Result> ();
    std::vector<Arg> tmp_value;
    _expr.evaluate (K, tmp_value);
    value.resize(tmp_value.size());
    typename std::vector<Arg>::const_iterator tmp = tmp_value.begin();
    for (typename std::vector<Result>::iterator
        iter = value.begin(),
        last = value.end(); iter != last; ++iter, ++tmp) {
      *iter = _f(*tmp);
    }
  }
  template<class This, class Result, class Arg, space_constant::valued_type ArgTag>
  struct evaluate_switch {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      typedef typename scalar_traits<Arg>::type T;
      space_constant::valued_type arg_valued_tag = obj._expr.valued_tag();
      switch (arg_valued_tag) {
        case space_constant::scalar:
          obj.template evaluate_internal<Result,T> (K, value);
          break;
        case space_constant::vector:
          obj.template evaluate_internal<Result, point_basic<T> > (K, value);
          break;
        case space_constant::tensor:
          obj.template evaluate_internal<Result, tensor_basic<T> > (K, value);
          break;
        default:
          error_macro ("unexpected valued tag="<<obj.valued_tag());
      }
    }
  };
  template<class This, class Result, class Arg>
  struct evaluate_switch <This, Result, Arg, space_constant::scalar> {
    typedef typename scalar_traits<Arg>::type T;
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      obj.template evaluate_internal<Result,T> (K, value);
    }
  };
  template<class This, class Result, class Arg>
  struct evaluate_switch <This, Result, Arg, space_constant::vector> {
    typedef typename scalar_traits<Arg>::type T;
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      obj.template evaluate_internal<Result, point_basic<T> > (K, value);
    }
  };
  template<class This, class Result, class Arg>
  struct evaluate_switch <This, Result, Arg, space_constant::tensor> {
    typedef typename scalar_traits<Arg>::type T;
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      obj.template evaluate_internal<Result, tensor_basic<T> > (K, value);
    }
  };
  template<class Result>
  void evaluate (const geo_element& K, std::vector<Result>& value) const
  {
    typedef typename generic_unary_traits<Function>::template with<Result>::argument_type  argument_hint1_type;
    typedef typename Expr::result_type  argument_hint2_type;
    typedef typename promote<argument_hint1_type, argument_hint2_type>::type  argument_type;
    typedef field_nonlinear_expr_uf<Function, Expr> This;
    static const space_constant::valued_type argument_tag = space_constant::valued_tag_traits<argument_type>::value;
    evaluate_switch <This, Result, argument_type, argument_tag> eval;
    eval (*this, K, value);
  }


  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const {
    _expr.initialize (omega, hat_x);
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
    return _expr.initialize (Xh);
  }

protected:
  template<class Result>
  void _check() const {
#ifdef TODO
    space_constant::valued_type  arg_valued_tag = space_constant::valued_tag_traits<argument_type>::value;
    check_macro (_expr.valued_tag() == arg_valued_tag, "invalid "
        << space_constant::valued_name(_expr.valued_tag())
        << "-valued expression for "
        << space_constant::valued_name(arg_valued_tag)
        << "-valued function argument");
#endif // TODO
  }
  Function                      _f;
  field_nonlinear_expr<Expr>    _expr;
};
template<class Function>
struct generic_binary_traits {
  template<class T>
  struct with {
    typedef typename boost::remove_const<
              typename boost::remove_reference<
                typename boost::binary_traits<Function>::first_argument_type>::type>::type
            first_argument_type;
    typedef typename boost::remove_const<
              typename boost::remove_reference<
                typename boost::binary_traits<Function>::second_argument_type>::type>::type
            second_argument_type;
    typedef typename boost::binary_traits<Function>::         result_type          result_type;
    typedef typename boost::binary_traits<Function>::       function_type        function_type;
  };
  template <class Arg1, class Arg2>
  struct result_hint {
    typedef typename boost::binary_traits<Function>::result_type type;
  };
  static space_constant::valued_type
  valued_tag (space_constant::valued_type, space_constant::valued_type) {
    return space_constant::valued_tag_traits<typename with<void>::result_type>::value;
  }
};
template<class Function, class Expr1, class Expr2>
class field_nonlinear_expr_bf : public detail::has_local_evaluate_member {
public:

  typedef geo_element::size_type                  size_type;
  typedef typename generic_binary_traits<Function>::template result_hint<typename Expr1::result_type,typename Expr2::result_type>::type result_type;
  typedef Float                                   float_type; // TODO
  typedef Float                                   scalar_type; // TODO
  typedef result_type                             value_type;
  typedef quadrature<float_type>                  pointset;
  typedef typename Expr1::memory_type             memory_type;


  field_nonlinear_expr_bf (const Function&             f, 
                    const Expr1& expr1,
                    const Expr2& expr2)
    : _f(f), _expr1(expr1), _expr2(expr2)
  {
  }

 
  static const space_constant::valued_type valued_hint = space_constant::valued_tag_traits<result_type>::value;

  space_constant::valued_type valued_tag() const {
    return generic_binary_traits<Function>::valued_tag(_expr1.valued_tag(), _expr2.valued_tag());
  }
  template<class Result, class Arg1, class Arg2>
  void evaluate_internal2 (const geo_element& K, std::vector<Result>& value) const {
    _check<Result,Arg1,Arg2> ();
    std::vector<Arg1> tmp1_value;
    std::vector<Arg2> tmp2_value;
    _expr1.evaluate (K, tmp1_value);
    _expr2.evaluate (K, tmp2_value);
    value.resize(tmp1_value.size());
    typename std::vector<Arg1>::const_iterator tmp1 = tmp1_value.begin();
    typename std::vector<Arg2>::const_iterator tmp2 = tmp2_value.begin();
    for (typename std::vector<Result>::iterator
        iter = value.begin(),
        last = value.end(); iter != last; ++iter, ++tmp1, ++tmp2) {
      *iter = _f (*tmp1, *tmp2);
    }
  }
  template<class This, class Result, class ReturnType, class Arg1, class Arg2>
  struct evaluate_internal {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      fatal_macro ("unexpected return type "    
        << pretty_typename_macro(ReturnType) << ": "
        << pretty_typename_macro(Result) << " was expected for function "
        << pretty_typename_macro(Function) << "("
        << pretty_typename_macro(Arg1) << ","
        << pretty_typename_macro(Arg2) << ")");
    }
  };
  template<class This, class Result, class Arg1, class Arg2>
  struct evaluate_internal<This,Result,Result,Arg1,Arg2> {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      obj.template evaluate_internal2 <Result,Arg1,Arg2> (K, value);
    }
  };
  template<class Result, class Arg1, class Arg2>
  void evaluate_call (const geo_element& K, std::vector<Result>& value) const {
    typedef typename generic_binary_traits<Function>::template result_hint<Arg1,Arg2>::type ReturnType;
    typedef field_nonlinear_expr_bf<Function, Expr1, Expr2> This;
    evaluate_internal<This,Result,ReturnType,Arg1,Arg2> eval_int;
    eval_int (*this, K, value);
  }
  template<class This, class Result,
        class Arg1,        space_constant::valued_type Arg1Tag,
        class Arg2,        space_constant::valued_type Arg2Tag>
  struct evaluate_switch {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      obj.template evaluate_call<Result, Arg1, Arg2> (K, value);
    }
  };
  template<class This, class Result,
        class Arg1,
        class Arg2>
  struct evaluate_switch<This, Result,
        Arg1,   space_constant::last_valued,
        Arg2,   space_constant::last_valued> {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      typedef typename scalar_traits<Arg1>::type T1;
      typedef typename scalar_traits<Arg2>::type T2;
      space_constant::valued_type arg1_valued_tag = obj._expr1.valued_tag();
      space_constant::valued_type arg2_valued_tag = obj._expr2.valued_tag();
      switch (arg1_valued_tag) {
        case space_constant::scalar: {
          switch (arg2_valued_tag) {
            case space_constant::scalar:
              obj.template evaluate_call<Result, T1, T2>                (K, value); break;
            case space_constant::vector:
              obj.template evaluate_call<Result, T1, point_basic<T2> >  (K, value); break;
            case space_constant::tensor:
              obj.template evaluate_call<Result, T1, tensor_basic<T2> > (K, value); break;
            default: error_macro ("unexpected second argument valued tag="<<arg2_valued_tag);
          }
          break;
        }
        case space_constant::vector: {
          switch (arg2_valued_tag) {
            case space_constant::scalar:
              obj.template evaluate_call<Result, point_basic<T1>, T2>                (K, value); break;
            case space_constant::vector:
              obj.template evaluate_call<Result, point_basic<T1>, point_basic<T2> >  (K, value); break;
            case space_constant::tensor:
              obj.template evaluate_call<Result, point_basic<T1>, tensor_basic<T2> > (K, value); break;
            default: error_macro ("unexpected second argument valued tag="<<arg2_valued_tag);
          }
          break;
        }
        case space_constant::tensor: {
          switch (arg2_valued_tag) {
            case space_constant::scalar:
              obj.template evaluate_call<Result, tensor_basic<T1>, T2>                (K, value); break;
            case space_constant::vector:
              obj.template evaluate_call<Result, tensor_basic<T1>, point_basic<T2> >  (K, value); break;
            case space_constant::tensor:
              obj.template evaluate_call<Result, tensor_basic<T1>, tensor_basic<T2> > (K, value); break;
            default: error_macro ("unexpected second argument valued tag="<<arg2_valued_tag);
          }
          break;
        }
        default: error_macro ("unexpected first argument valued tag="<<arg1_valued_tag);
      }
    }
  };
  template<class This, class Result,
        class Arg1,        space_constant::valued_type Arg1Tag,
        class Arg2>
  struct evaluate_switch<This, Result,
        Arg1,   Arg1Tag,
        Arg2,   space_constant::last_valued> {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      typedef typename scalar_traits<Arg2>::type T2;
      space_constant::valued_type arg2_valued_tag = obj._expr2.valued_tag();
      switch (arg2_valued_tag) {
        case space_constant::scalar:
          obj.template evaluate_call<Result, Arg1, T2>                (K, value); break;
        case space_constant::vector:
          obj.template evaluate_call<Result, Arg1, point_basic<T2> >  (K, value); break;
        case space_constant::tensor:
          obj.template evaluate_call<Result, Arg1, tensor_basic<T2> > (K, value); break;
        default: error_macro ("unexpected second argument valued tag="<<arg2_valued_tag);
      }
    }
  };
  template<class This, class Result,
        class Arg1,     
        class Arg2,        space_constant::valued_type Arg2Tag>
  struct evaluate_switch<This, Result,
        Arg1,              space_constant::last_valued,
        Arg2,              Arg2Tag> {
    void operator() (const This& obj, const geo_element& K, std::vector<Result>& value) const {
      typedef typename scalar_traits<Arg1>::type T1;
      space_constant::valued_type arg1_valued_tag = obj._expr1.valued_tag();
      switch (arg1_valued_tag) {
        case space_constant::scalar:
          obj.template evaluate_call<Result, T1, Arg2>               (K, value); break;
        case space_constant::vector:
          obj.template evaluate_call<Result, point_basic<T1>, Arg2>  (K, value); break;
        case space_constant::tensor:
          obj.template evaluate_call<Result, tensor_basic<T1>, Arg2> (K, value); break;
        default: error_macro ("unexpected first argument valued tag="<<arg1_valued_tag);
      }
    }
  };
  template<class Result>
  void evaluate (const geo_element& K, std::vector<Result>& value) const
  {
    typedef typename generic_binary_traits<Function>::template with<Result>::first_argument_type  first_argument_hint1_type;
    typedef typename Expr1::result_type                                                        first_argument_hint2_type;
    typedef typename promote<first_argument_hint1_type, first_argument_hint2_type>::type       first_argument_type;
    typedef typename generic_binary_traits<Function>::template with<Result>::second_argument_type  second_argument_hint1_type;
    typedef typename Expr1::result_type                                                        second_argument_hint2_type;
    typedef typename promote<second_argument_hint1_type, second_argument_hint2_type>::type     second_argument_type;
    static const space_constant::valued_type first_argument_tag = space_constant::valued_tag_traits<first_argument_type>::value;
    static const space_constant::valued_type second_argument_tag = space_constant::valued_tag_traits<second_argument_type>::value;
    typedef field_nonlinear_expr_bf<Function, Expr1, Expr2> This;
    evaluate_switch <This, Result, 
        first_argument_type,   first_argument_tag,
        second_argument_type, second_argument_tag>   eval;
    eval (*this, K, value);
  }
  void initialize (const geo_basic<float_type,memory_type>& omega, const pointset& hat_x) const
  {
    _expr1.initialize (omega, hat_x); 
    _expr2.initialize (omega, hat_x);
  }
  bool initialize (const space_basic<float_type,memory_type>& Xh) const {
    bool is_homogeneous1 = _expr1.initialize (Xh);
    bool is_homogeneous2 = _expr2.initialize (Xh);
    return is_homogeneous1 && is_homogeneous2;
  }

protected:
  template<class Result, class Arg1, class Arg2>
  void _check() const
  {
    typedef typename generic_binary_traits<Function>::template result_hint<Arg1,Arg2>::type Result2;
    space_constant::valued_type  arg1_valued_tag = space_constant::valued_tag_traits<Arg1>::value;
    space_constant::valued_type  arg2_valued_tag = space_constant::valued_tag_traits<Arg2>::value;
    space_constant::valued_type  resu_valued_tag = space_constant::valued_tag_traits<Result>::value;
    space_constant::valued_type  res2_valued_tag = space_constant::valued_tag_traits<Result2>::value;
    check_macro (_expr1.valued_tag() == arg1_valued_tag, "invalid "
        << space_constant::valued_name(_expr1.valued_tag())
        << "-valued expression for "
        << space_constant::valued_name(arg1_valued_tag)
        << "-valued function first argument");
    check_macro (_expr2.valued_tag() == arg2_valued_tag, "invalid "
        << space_constant::valued_name(_expr2.valued_tag())
        << "-valued expression for "
        << space_constant::valued_name(arg2_valued_tag)
        << "-valued function second argument");
    check_macro (resu_valued_tag == res2_valued_tag, "invalid "
        << space_constant::valued_name(resu_valued_tag)
        << "-valued result field for "
        << space_constant::valued_name(res2_valued_tag)
        << "-valued function return type");
  }
  Function  _f;
  Expr1     _expr1;
  Expr2     _expr2;
};

#ifndef TO_CLEAN
template<class Function, class Expr>
struct compose_result {
  typedef field_nonlinear_expr<field_nonlinear_expr_uf<Function,Expr> > type;
};

template<class Function, class T, class M>
struct compose_result<Function, field_basic<T,M> > { 
  typedef field_nonlinear_expr<field_nonlinear_expr_uf<Function,field_expr_terminal_field<T,M> > > type;
};
#endif // TO_CLEAN

} // namespace rheolef
#endif // _RHEOLEF_FIELD_EXPR_NONLINEAR_H