---

more/gen/lambda_math.h

Go to the documentation of this file.

//  more/lambda_math.h -- lambda-overloads for basic math functions
//  Copyright (C) 1998--2001  Petter Urkedal (petter.urkedal@matfys.lth.se)

//  This file 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 2 of the License, or
//  (at your option) any later version.

//  This file 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//  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 GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.

//  $Id: lambda_math.h,v 1.1 2002/05/30 18:01:37 petter_urkedal Exp $


#ifndef MORE_GEN_LAMBDA_MATH_H
#define MORE_GEN_LAMBDA_MATH_H

#include <cmath>
#include <cstdlib>
#include <more/math/math.h>

namespace more {
namespace gen {

  ///\if bits
  namespace lambda_kns {
#define MORE_DEF(Name, Result)\
    using more::Name;\
    template<typename Expr> struct Name##_expr {};\
    template<typename Expr>\
    struct expr< Name##_expr<Expr> > {\
        typedef typename Expr::result_type argument_type;\
        typedef Result result_type;\
        template<typename Assign>\
        result_type operator()(const Assign& a) {\
            return Name(x(a));\
        }\
        template<typename Assign>\
        result_type operator()(const Assign& a) const {\
            return Name(x(a));\
        }\
        explicit expr(const Expr& x_) : x(x_) {}\
    private:\
        Expr x;\
    };\
    template<typename Expr>\
    expr< Name##_expr< expr<Expr> > >\
    Name(const expr<Expr>& x) {\
        return expr< Name##_expr< expr<Expr> > >(x);\
    }
//#enddef

    MORE_DEF(ceil, argument_type)  MORE_DEF(floor, argument_type)
    MORE_DEF(sin, argument_type)   MORE_DEF(cos, argument_type)
    MORE_DEF(tan, argument_type)
    MORE_DEF(asin, argument_type)  MORE_DEF(acos, argument_type)
    MORE_DEF(atan, argument_type)
    MORE_DEF(sinh, argument_type)  MORE_DEF(cosh, argument_type)
    MORE_DEF(tanh, argument_type)  MORE_DEF(exp, argument_type)
    MORE_DEF(log, argument_type)   MORE_DEF(log10, argument_type)
    MORE_DEF(sqrt, argument_type)
    MORE_DEF(pow2, argument_type)  MORE_DEF(pow3, argument_type)
    MORE_DEF(fabs, typename norm_type_<argument_type>::eval)
    MORE_DEF(abs,  typename norm_type_<argument_type>::eval)
//    MORE_DEF(norm, norm_type_<argument_type>::eval)
    MORE_DEF(norm, double)
#undef MORE_DEF

#define MORE_DEF(Name)\
    using more::Name;\
    template<typename Expr1, typename Expr2> struct Name##_expr {};\
    template<typename Expr1, typename Expr2>\
      struct expr< Name##_expr<Expr1, Expr2> > {\
          typedef typename Expr1::result_type result_type;\
          template<typename Assign>\
            result_type operator()(const Assign& a) {\
                return Name(x(a), y(a));\
          }\
          template<typename Assign>\
            result_type operator()(const Assign& a) const {\
                return Name(x(a), y(a));\
            }\
          expr(const Expr1& x_, const Expr2& y_) : x(x_), y(y_) {}\
        private:\
          Expr1 x;\
          Expr2 y;\
      };\
    template<typename T1, typename T2>\
      expr<Name##_expr< typename which_expr<T1>::eval,\
                        typename which_expr<T2>::eval > >\
      Name(const T1& x, const T2& y) {\
          return expr< Name##_expr< typename which_expr<T1>::eval,\
                                    typename which_expr<T2>::eval > >(x, y);\
      }
//#enddef

    MORE_DEF(atan2) MORE_DEF(fmod)
    MORE_DEF(ldexp) // obs: different type args
    MORE_DEF(pow) // obs: different or equal args
#undef MORE_DEF
  }
  ///\endif

}} // more::gen

#endif

---