Sacado Package Browser (Single Doxygen Collection): Sacado

00001 // $Id: Sacado_MathFunctions.hpp,v 1.4.2.2 2009/03/05 19:41:29 etphipp Exp $ 
00002 // $Source: /space/CVS/Trilinos/packages/sacado/src/Sacado_MathFunctions.hpp,v $ 
00003 // @HEADER
00004 // ***********************************************************************
00005 // 
00006 //                           Sacado Package
00007 //                 Copyright (2006) Sandia Corporation
00008 // 
00009 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
00010 // the U.S. Government retains certain rights in this software.
00011 // 
00012 // This library is free software; you can redistribute it and/or modify
00013 // it under the terms of the GNU Lesser General Public License as
00014 // published by the Free Software Foundation; either version 2.1 of the
00015 // License, or (at your option) any later version.
00016 //  
00017 // This library is distributed in the hope that it will be useful, but
00018 // WITHOUT ANY WARRANTY; without even the implied warranty of
00019 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00020 // Lesser General Public License for more details.
00021 //  
00022 // You should have received a copy of the GNU Lesser General Public
00023 // License along with this library; if not, write to the Free Software
00024 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
00025 // USA
00026 // Questions? Contact David M. Gay (dmgay@sandia.gov) or Eric T. Phipps
00027 // (etphipp@sandia.gov).
00028 // 
00029 // ***********************************************************************
00030 // @HEADER
00031 
00032 #ifndef SACADO_MATHFUNCTIONS_HPP
00033 #define SACADO_MATHFUNCTIONS_HPP
00034 
00035 #define UNARYFUNC_MACRO(OP,FADOP)         \
00036 namespace Sacado {              \
00037                   \
00038   namespace Fad {             \
00039     template <typename T> class FADOP;          \
00040     template <typename T> class Expr;         \
00041     template <typename T, template<typename> class Op> class UnaryExpr; \
00042     template <typename T>           \
00043     Expr< UnaryExpr< Expr<T>, FADOP > > OP (const Expr<T>&);    \
00044   }                 \
00045                   \
00046   namespace ELRFad {              \
00047     template <typename T> class FADOP;          \
00048     template <typename T> class Expr;         \
00049     template <typename T, template<typename> class Op> class UnaryExpr; \
00050     template <typename T>           \
00051     Expr< UnaryExpr< Expr<T>, FADOP > > OP (const Expr<T>&);    \
00052   }                 \
00053                   \
00054   namespace CacheFad {              \
00055     template <typename T> class FADOP;          \
00056     template <typename T> class Expr;         \
00057     template <typename T, template<typename> class Op> class UnaryExpr; \
00058     template <typename T>           \
00059     Expr< UnaryExpr< Expr<T>, FADOP > > OP (const Expr<T>&);    \
00060   }                 \
00061                   \
00062   namespace Tay {             \
00063     template <typename T> class Taylor;         \
00064     template <typename T> Taylor<T> OP (const Taylor<T>&);    \
00065   }                 \
00066                   \
00067   namespace FlopCounterPack {           \
00068     template <typename T> class ScalarFlopCounter;      \
00069     template <typename T>           \
00070     ScalarFlopCounter<T> OP (const ScalarFlopCounter<T>&);    \
00071   }                 \
00072                   \
00073   namespace Rad {             \
00074     template <typename T> class ADvari;         \
00075     template <typename T> class IndepADvar;       \
00076     template <typename T> ADvari<T>& OP (const ADvari<T>&);   \
00077     template <typename T> ADvari<T>& OP (const IndepADvar<T>&);   \
00078   }                 \
00079 }                                                                       \
00080                                                                         \
00081 namespace std {                                                         \
00082   using Sacado::Fad::OP;            \
00083   using Sacado::ELRFad::OP;           \
00084   using Sacado::CacheFad::OP;           \
00085   using Sacado::Tay::OP;            \
00086   using Sacado::FlopCounterPack::OP;          \
00087   using Sacado::Rad::OP;            \
00088 }
00089 
00090 UNARYFUNC_MACRO(exp, ExpOp)
00091 UNARYFUNC_MACRO(log, LogOp)
00092 UNARYFUNC_MACRO(log10, Log10Op)
00093 UNARYFUNC_MACRO(sqrt, SqrtOp)
00094 UNARYFUNC_MACRO(cos, CosOp)
00095 UNARYFUNC_MACRO(sin, SinOp)
00096 UNARYFUNC_MACRO(tan, TanOp)
00097 UNARYFUNC_MACRO(acos, ACosOp)
00098 UNARYFUNC_MACRO(asin, ASinOp)
00099 UNARYFUNC_MACRO(atan, ATanOp)
00100 UNARYFUNC_MACRO(cosh, CoshOp)
00101 UNARYFUNC_MACRO(sinh, SinhOp)
00102 UNARYFUNC_MACRO(tanh, TanhOp)
00103 UNARYFUNC_MACRO(acosh, ACoshOp)
00104 UNARYFUNC_MACRO(asinh, ASinhOp)
00105 UNARYFUNC_MACRO(atanh, ATanhOp)
00106 UNARYFUNC_MACRO(abs, AbsOp)
00107 UNARYFUNC_MACRO(fabs, FAbsOp)
00108 
00109 #undef UNARYFUNC_MACRO
00110 
00111 #define BINARYFUNC_MACRO(OP,FADOP)          \
00112 namespace Sacado {              \
00113                   \
00114   namespace Fad {             \
00115     template <typename T1, typename T2> class FADOP;      \
00116     template <typename T> class Expr;         \
00117     template <typename T> class ConstExpr;        \
00118     template <typename T1, typename T2,         \
00119         template<typename,typename> class Op> class BinaryExpr; \
00120     template <typename T1, typename T2>         \
00121     Expr< BinaryExpr< Expr<T1>, Expr<T2>, FADOP > >     \
00122     OP (const Expr<T1>&, const Expr<T2>&);        \
00123                   \
00124     template <typename T>           \
00125     Expr< BinaryExpr< Expr<T>, Expr<T>, FADOP > >     \
00126     OP (const Expr<T>&, const Expr<T>&);        \
00127                   \
00128     template <typename T>           \
00129     Expr< BinaryExpr< ConstExpr<typename Expr<T>::value_type>,    \
00130           Expr<T>, FADOP > >        \
00131     OP (const typename Expr<T>::value_type&, const Expr<T>&);   \
00132                   \
00133     template <typename T>           \
00134     Expr< BinaryExpr< Expr<T>, ConstExpr<typename Expr<T>::value_type>, \
00135           FADOP > >           \
00136     OP (const Expr<T>&, const typename Expr<T>::value_type&);   \
00137   }                 \
00138                   \
00139   namespace ELRFad {              \
00140     template <typename T1, typename T2> class FADOP;      \
00141     template <typename T> class Expr;         \
00142     template <typename T> class ConstExpr;        \
00143     template <typename T1, typename T2,         \
00144         template<typename,typename> class Op> class BinaryExpr; \
00145     template <typename T1, typename T2>         \
00146     Expr< BinaryExpr< Expr<T1>, Expr<T2>, FADOP > >     \
00147     OP (const Expr<T1>&, const Expr<T2>&);        \
00148                   \
00149     template <typename T>           \
00150     Expr< BinaryExpr< Expr<T>, Expr<T>, FADOP > >     \
00151     OP (const Expr<T>&, const Expr<T>&);        \
00152                   \
00153     template <typename T>           \
00154     Expr< BinaryExpr< ConstExpr<typename Expr<T>::value_type>,    \
00155           Expr<T>, FADOP > >        \
00156     OP (const typename Expr<T>::value_type&, const Expr<T>&);   \
00157                   \
00158     template <typename T>           \
00159     Expr< BinaryExpr< Expr<T>, ConstExpr<typename Expr<T>::value_type>, \
00160           FADOP > >           \
00161     OP (const Expr<T>&, const typename Expr<T>::value_type&);   \
00162   }                 \
00163                   \
00164   namespace CacheFad {              \
00165     template <typename T1, typename T2> class FADOP;      \
00166     template <typename T> class Expr;         \
00167     template <typename T> class ConstExpr;        \
00168     template <typename T1, typename T2,         \
00169         template<typename,typename> class Op> class BinaryExpr; \
00170     template <typename T1, typename T2>         \
00171     Expr< BinaryExpr< Expr<T1>, Expr<T2>, FADOP > >     \
00172     OP (const Expr<T1>&, const Expr<T2>&);        \
00173                   \
00174     template <typename T>           \
00175     Expr< BinaryExpr< Expr<T>, Expr<T>, FADOP > >     \
00176     OP (const Expr<T>&, const Expr<T>&);        \
00177                   \
00178     template <typename T>           \
00179     Expr< BinaryExpr< ConstExpr<typename Expr<T>::value_type>,    \
00180           Expr<T>, FADOP > >        \
00181     OP (const typename Expr<T>::value_type&, const Expr<T>&);   \
00182                   \
00183     template <typename T>           \
00184     Expr< BinaryExpr< Expr<T>, ConstExpr<typename Expr<T>::value_type>, \
00185           FADOP > >           \
00186     OP (const Expr<T>&, const typename Expr<T>::value_type&);   \
00187   }                 \
00188                   \
00189   namespace Tay {             \
00190     template <typename T> class Taylor;         \
00191     template <typename T> Taylor<T> OP (const Taylor<T>&,   \
00192           const Taylor<T>&);    \
00193     template <typename T> Taylor<T> OP (const T&,     \
00194           const Taylor<T>&);    \
00195     template <typename T> Taylor<T> OP (const Taylor<T>&,   \
00196           const T&);      \
00197   }                 \
00198                   \
00199   namespace FlopCounterPack {           \
00200     template <typename T> class ScalarFlopCounter;      \
00201     template <typename T>           \
00202     ScalarFlopCounter<T> OP (const ScalarFlopCounter<T>&,   \
00203            const ScalarFlopCounter<T>&);    \
00204     template <typename T>           \
00205     ScalarFlopCounter<T> OP (const T&,          \
00206            const ScalarFlopCounter<T>);   \
00207     template <typename T>           \
00208     ScalarFlopCounter<T> OP (const ScalarFlopCounter<T>&,   \
00209            const T&);         \
00210     template <typename T>           \
00211     ScalarFlopCounter<T> OP (const int&,        \
00212            const ScalarFlopCounter<T>);   \
00213     template <typename T>           \
00214     ScalarFlopCounter<T> OP (const ScalarFlopCounter<T>&,   \
00215            const int&);       \
00216   }                 \
00217                   \
00218   namespace Rad {             \
00219     template <typename T> class ADvari;         \
00220     template <typename T> class IndepADvar;       \
00221     template <typename T> class DoubleAvoid;        \
00222     template <typename T> ADvari<T>& OP (const ADvari<T>&,    \
00223            const ADvari<T>&);   \
00224     template <typename T> ADvari<T>& OP (const IndepADvar<T>&,    \
00225            const ADvari<T>&);   \
00226     template <typename T> ADvari<T>& OP (T,       \
00227            const ADvari<T>&);   \
00228     template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::dtype, \
00229            const ADvari<T>&);   \
00230     template <typename T> ADvari<T>& OP (int,       \
00231            const ADvari<T>&);   \
00232     template <typename T> ADvari<T>& OP (long,        \
00233            const ADvari<T>&);   \
00234     template <typename T> ADvari<T>& OP (const ADvari<T>&,    \
00235            const IndepADvar<T>&);   \
00236     template <typename T> ADvari<T>& OP (const ADvari<T>&,    \
00237            T);        \
00238     template <typename T> ADvari<T>& OP (const ADvari<T>&,    \
00239            typename DoubleAvoid<T>::dtype); \
00240     template <typename T> ADvari<T>& OP (const ADvari<T>&,    \
00241            int);        \
00242     template <typename T> ADvari<T>& OP (const ADvari<T>&,    \
00243            long);       \
00244     template <typename T> ADvari<T>& OP (const IndepADvar<T>&,    \
00245            const IndepADvar<T>&);   \
00246     template <typename T> ADvari<T>& OP (T,       \
00247            const IndepADvar<T>&);   \
00248     template <typename T> ADvari<T>& OP (typename DoubleAvoid<T>::dtype, \
00249            const IndepADvar<T>&);   \
00250     template <typename T> ADvari<T>& OP (int,       \
00251            const IndepADvar<T>&);   \
00252     template <typename T> ADvari<T>& OP (long,        \
00253            const IndepADvar<T>&);   \
00254     template <typename T> ADvari<T>& OP (const IndepADvar<T>&,    \
00255            T);        \
00256     template <typename T> ADvari<T>& OP (const IndepADvar<T>&,    \
00257            typename DoubleAvoid<T>::dtype); \
00258     template <typename T> ADvari<T>& OP (const IndepADvar<T>&,    \
00259            int);        \
00260     template <typename T> ADvari<T>& OP (const IndepADvar<T>&,    \
00261            long);       \
00262   }                 \
00263                   \
00264 }                 \
00265                                                                         \
00266 namespace std {                                                         \
00267   using Sacado::Fad::OP;            \
00268   using Sacado::ELRFad::OP;           \
00269   using Sacado::CacheFad::OP;           \
00270   using Sacado::Tay::OP;            \
00271   using Sacado::FlopCounterPack::OP;          \
00272   using Sacado::Rad::OP;            \
00273 }
00274 
00275 BINARYFUNC_MACRO(atan2, Atan2Op)
00276 BINARYFUNC_MACRO(pow, PowerOp)
00277 BINARYFUNC_MACRO(max, MaxOp)
00278 BINARYFUNC_MACRO(min, MinOp)
00279 
00280 #undef BINARYFUNC_MACRO
00281 
00282 #endif // SACADO_MATHFUNCTIONS_HPP