Sacado Package Browser (Single Doxygen Collection) Version of the Day
Sacado_Fad_SimpleFadOps.hpp
Go to the documentation of this file.
00001 // $Id$ 
00002 // $Source$ 
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_FAD_SIMPLEFADOPS_HPP
00033 #define SACADO_FAD_SIMPLEFADOPS_HPP
00034 
00035 #include "Sacado_cmath.hpp"
00036 #include <ostream>  // for std::ostream
00037 
00038 namespace Sacado {
00039 
00040   namespace Fad {
00041 
00042     template <typename ValueT>
00043     SimpleFad<ValueT>
00044     operator + (const SimpleFad<ValueT>& a) {
00045       return a;
00046     }
00047 
00048     template <typename ValueT>
00049     SimpleFad<ValueT>
00050     operator - (const SimpleFad<ValueT>& a) {
00051       return SimpleFad<ValueT>(a, -a.val(), -1.0);
00052     }
00053 
00054     template <typename ValueT>
00055     SimpleFad<ValueT>
00056     exp(const SimpleFad<ValueT>& a) {
00057       ValueT t1 = std::exp(a.val());
00058       return SimpleFad<ValueT>(a, t1, t1);
00059     }
00060 
00061     template <typename ValueT>
00062     SimpleFad<ValueT>
00063     log(const SimpleFad<ValueT>& a) {
00064       return SimpleFad<ValueT>(a, std::log(a.val()), 1.0/a.val());
00065     }
00066 
00067     template <typename ValueT>
00068     SimpleFad<ValueT>
00069     log10(const SimpleFad<ValueT>& a) {
00070       return SimpleFad<ValueT>(a, std::log10(a.val()), 
00071              1.0/(std::log(10.0)*a.val()));
00072     }
00073     
00074     template <typename ValueT>
00075     SimpleFad<ValueT>
00076     sqrt(const SimpleFad<ValueT>& a) {
00077       ValueT t1 = std::sqrt(a.val());
00078       ValueT t2 = 1.0/(2.0*t1);
00079       return SimpleFad<ValueT>(a, t1, t2);
00080     }
00081 
00082     template <typename ValueT>
00083     SimpleFad<ValueT>
00084     cos(const SimpleFad<ValueT>& a) {
00085       return SimpleFad<ValueT>(a, std::cos(a.val()), -std::sin(a.val()));
00086     }
00087 
00088     template <typename ValueT>
00089     SimpleFad<ValueT>
00090     sin(const SimpleFad<ValueT>& a) {
00091       return SimpleFad<ValueT>(a, std::sin(a.val()), std::cos(a.val()));
00092     }
00093 
00094     template <typename ValueT>
00095     SimpleFad<ValueT>
00096     tan(const SimpleFad<ValueT>& a) {
00097       ValueT t1 = std::tan(a.val());
00098       ValueT t2 = 1.0 + t1*t1;
00099       return SimpleFad<ValueT>(a, t1, t2);
00100     }
00101 
00102     template <typename ValueT>
00103     SimpleFad<ValueT>
00104     acos(const SimpleFad<ValueT>& a) {
00105       return SimpleFad<ValueT>(a, std::acos(a.val()), 
00106              -1.0/std::sqrt(1.0 - a.val()*a.val()));
00107     }
00108 
00109     template <typename ValueT>
00110     SimpleFad<ValueT>
00111     asin(const SimpleFad<ValueT>& a) {
00112       return SimpleFad<ValueT>(a, std::asin(a.val()), 
00113              1.0/std::sqrt(1.0 - a.val()*a.val()));
00114     }
00115 
00116     template <typename ValueT>
00117     SimpleFad<ValueT>
00118     atan(const SimpleFad<ValueT>& a) {
00119       return SimpleFad<ValueT>(a, std::atan(a.val()), 
00120              1.0/(1.0 + a.val()*a.val()));
00121     }
00122 
00123     template <typename ValueT>
00124     SimpleFad<ValueT>
00125     cosh(const SimpleFad<ValueT>& a) {
00126       return SimpleFad<ValueT>(a, std::cosh(a.val()), std::sinh(a.val()));
00127     }
00128 
00129     template <typename ValueT>
00130     SimpleFad<ValueT>
00131     sinh(const SimpleFad<ValueT>& a) {
00132       return SimpleFad<ValueT>(a, std::sinh(a.val()), std::cosh(a.val()));
00133     }
00134 
00135     template <typename ValueT>
00136     SimpleFad<ValueT>
00137     tanh(const SimpleFad<ValueT>& a) {
00138       ValueT t = std::cosh(a.val());
00139       t = 1.0/(t*t);
00140       return SimpleFad<ValueT>(a, std::tanh(a.val()), t);
00141     }
00142 
00143     template <typename ValueT>
00144     SimpleFad<ValueT>
00145     acosh(const SimpleFad<ValueT>& a) {
00146       return SimpleFad<ValueT>(a, std::acosh(a.val()), 
00147              1.0/std::sqrt(a.val()*a.val()-1.0));
00148     }
00149 
00150     template <typename ValueT>
00151     SimpleFad<ValueT>
00152     asinh(const SimpleFad<ValueT>& a) {
00153       return SimpleFad<ValueT>(a, std::asinh(a.val()), 
00154              1.0/std::sqrt(1.0 + a.val()*a.val()));
00155     }
00156 
00157     template <typename ValueT>
00158     SimpleFad<ValueT>
00159     atanh(const SimpleFad<ValueT>& a) {
00160       return SimpleFad<ValueT>(a, std::atanh(a.val()), 
00161              1.0 /(1.0 - a.val()*a.val()));
00162     }
00163 
00164     template <typename ValueT>
00165     SimpleFad<ValueT>
00166     abs(const SimpleFad<ValueT>& a) {
00167       ValueT t = 1.0;
00168       if (a.val() < 0)
00169   t = -1.0;
00170       return SimpleFad<ValueT>(a, std::abs(a.val()), t);
00171     }
00172 
00173     template <typename ValueT>
00174     SimpleFad<ValueT>
00175     fabs(const SimpleFad<ValueT>& a) {
00176       ValueT t = 1.0;
00177       if (a.val() < 0)
00178   t = -1.0;
00179       return SimpleFad<ValueT>(a, std::fabs(a.val()), t);
00180     }
00181 
00182     template <typename ValueT>
00183     SimpleFad<ValueT>
00184     operator + (const SimpleFad<ValueT>& a, 
00185     const SimpleFad<ValueT>& b) {
00186       int sz = a.size() >= b.size() ? a.size() : b.size();
00187       SimpleFad<ValueT> c(sz, a.val() + b.val());
00188       if (a.hasFastAccess() && b.hasFastAccess())
00189   for (int i=0; i<sz; i++)
00190     c.fastAccessDx(i) = a.fastAccessDx(i) + b.fastAccessDx(i);
00191       else if (a.hasFastAccess())
00192   for (int i=0; i<sz; i++)
00193     c.fastAccessDx(i) = a.fastAccessDx(i);
00194       else if (b.hasFastAccess())
00195   for (int i=0; i<sz; i++)
00196     c.fastAccessDx(i) = b.fastAccessDx(i);
00197 
00198       return c;
00199     }
00200 
00201     template <typename ValueT>
00202     SimpleFad<ValueT>
00203     operator + (const typename SimpleFad<ValueT>::value_type& a, 
00204     const SimpleFad<ValueT>& b) {
00205       return SimpleFad<ValueT>(b, a+b.val(), 1.0);
00206     }
00207 
00208     template <typename ValueT>
00209     SimpleFad<ValueT>
00210     operator + (const SimpleFad<ValueT>& a, 
00211     const typename SimpleFad<ValueT>::value_type& b) {
00212       return SimpleFad<ValueT>(a, a.val()+b, 1.0);
00213     }
00214 
00215     template <typename ValueT>
00216     SimpleFad<ValueT>
00217     operator - (const SimpleFad<ValueT>& a, 
00218     const SimpleFad<ValueT>& b) {
00219       int sz = a.size() >= b.size() ? a.size() : b.size();
00220       SimpleFad<ValueT> c(sz, a.val() - b.val());
00221       if (a.hasFastAccess() && b.hasFastAccess())
00222   for (int i=0; i<sz; i++)
00223     c.fastAccessDx(i) = a.fastAccessDx(i) - b.fastAccessDx(i);
00224       else if (a.hasFastAccess())
00225   for (int i=0; i<sz; i++)
00226     c.fastAccessDx(i) = a.fastAccessDx(i);
00227       else if (b.hasFastAccess())
00228   for (int i=0; i<sz; i++)
00229     c.fastAccessDx(i) = -b.fastAccessDx(i);
00230 
00231       return c;
00232     }
00233 
00234     template <typename ValueT>
00235     SimpleFad<ValueT>
00236     operator - (const typename SimpleFad<ValueT>::value_type& a, 
00237     const SimpleFad<ValueT>& b) {
00238       return SimpleFad<ValueT>(b, a-b.val(), -1.0);
00239     }
00240 
00241     template <typename ValueT>
00242     SimpleFad<ValueT>
00243     operator - (const SimpleFad<ValueT>& a, 
00244     const typename SimpleFad<ValueT>::value_type& b) {
00245       return SimpleFad<ValueT>(a, a.val()-b, 1.0);
00246     }
00247 
00248     template <typename ValueT>
00249     SimpleFad<ValueT>
00250     operator * (const SimpleFad<ValueT>& a, 
00251     const SimpleFad<ValueT>& b) {
00252       int sz = a.size() >= b.size() ? a.size() : b.size();
00253       SimpleFad<ValueT> c(sz, a.val() * b.val());
00254       if (a.hasFastAccess() && b.hasFastAccess())
00255   for (int i=0; i<sz; i++)
00256     c.fastAccessDx(i) = 
00257       a.fastAccessDx(i)*b.val() + b.fastAccessDx(i)*a.val();
00258       else if (a.hasFastAccess())
00259   for (int i=0; i<sz; i++)
00260     c.fastAccessDx(i) = a.fastAccessDx(i)*b.val();
00261       else if (b.hasFastAccess())
00262   for (int i=0; i<sz; i++)
00263     c.fastAccessDx(i) = b.fastAccessDx(i)*a.val();
00264 
00265       return c;
00266     }
00267 
00268     template <typename ValueT>
00269     SimpleFad<ValueT>
00270     operator * (const typename SimpleFad<ValueT>::value_type& a, 
00271     const SimpleFad<ValueT>& b) {
00272       return SimpleFad<ValueT>(b, a*b.val(), a);
00273     }
00274 
00275     template <typename ValueT>
00276     SimpleFad<ValueT>
00277     operator * (const SimpleFad<ValueT>& a, 
00278     const typename SimpleFad<ValueT>::value_type& b) {
00279       return SimpleFad<ValueT>(a, a.val()*b, b);
00280     }
00281 
00282     template <typename ValueT>
00283     SimpleFad<ValueT>
00284     operator / (const SimpleFad<ValueT>& a, 
00285     const SimpleFad<ValueT>& b) {
00286       int sz = a.size() >= b.size() ? a.size() : b.size();
00287       SimpleFad<ValueT> c(sz, a.val() / b.val());
00288       if (a.hasFastAccess() && b.hasFastAccess()) {
00289   ValueT t = b.val()*b.val();
00290   for (int i=0; i<sz; i++)
00291     c.fastAccessDx(i) = 
00292       (a.fastAccessDx(i)*b.val() - b.fastAccessDx(i)*a.val()) / t;
00293       }
00294       else if (a.hasFastAccess())
00295   for (int i=0; i<sz; i++)
00296     c.fastAccessDx(i) = a.fastAccessDx(i)/b.val();
00297       else if (b.hasFastAccess()) {
00298   ValueT t = -a.val()/(b.val()*b.val());
00299   for (int i=0; i<sz; i++)
00300     c.fastAccessDx(i) = b.fastAccessDx(i)*t;
00301       }
00302 
00303       return c;
00304     }
00305 
00306     template <typename ValueT>
00307     SimpleFad<ValueT>
00308     operator / (const typename SimpleFad<ValueT>::value_type& a, 
00309     const SimpleFad<ValueT>& b) {
00310       return SimpleFad<ValueT>(b, a/b.val(), -a/(b.val()*b.val()));
00311     }
00312 
00313     template <typename ValueT>
00314     SimpleFad<ValueT>
00315     operator / (const SimpleFad<ValueT>& a, 
00316     const typename SimpleFad<ValueT>::value_type& b) {
00317       return SimpleFad<ValueT>(a, a.val()/b, 1.0/b);
00318     }
00319 
00320     template <typename ValueT>
00321     SimpleFad<ValueT>
00322     pow(const SimpleFad<ValueT>& a, 
00323   const SimpleFad<ValueT>& b) {
00324       int sz = a.size() >= b.size() ? a.size() : b.size();
00325       SimpleFad<ValueT> c(sz, std::pow(a.val(), b.val()));
00326       typedef typename SimpleFad<ValueT>::value_type value_type;
00327       if (a.hasFastAccess() && b.hasFastAccess()) {
00328   if (a.val() != value_type(0)) {
00329     ValueT t1 = c.val()*b.val()/a.val();
00330     ValueT t2 = c.val()*std::log(a.val());
00331     for (int i=0; i<sz; i++)
00332       c.fastAccessDx(i) = 
00333         a.fastAccessDx(i)*t1 + b.fastAccessDx(i)*t2;
00334   }
00335       }
00336       else if (a.hasFastAccess()) {
00337   if (a.val() != value_type(0)) {
00338     ValueT t1 = c.val()*b.val()/a.val();
00339     for (int i=0; i<sz; i++)
00340       c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
00341   }
00342       }
00343       else if (b.hasFastAccess()) {
00344   if (a.val() != value_type(0)) {
00345     ValueT t2 = c.val()*std::log(a.val());
00346     for (int i=0; i<sz; i++)
00347       c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
00348   }
00349       }
00350 
00351       return c;
00352     }
00353 
00354     template <typename ValueT>
00355     SimpleFad<ValueT>
00356     pow(const typename SimpleFad<ValueT>::value_type& a, 
00357   const SimpleFad<ValueT>& b) {
00358       typedef typename SimpleFad<ValueT>::value_type value_type;
00359       ValueT t = std::pow(a,b.val());
00360       if (a != value_type(0))
00361   return SimpleFad<ValueT>(b, t, t*std::log(a));
00362       else
00363   return SimpleFad<ValueT>(b, t, value_type(0));
00364     }
00365 
00366     template <typename ValueT>
00367     SimpleFad<ValueT>
00368     pow(const SimpleFad<ValueT>& a, 
00369   const typename SimpleFad<ValueT>::value_type& b) {
00370       typedef typename SimpleFad<ValueT>::value_type value_type;
00371       ValueT t = std::pow(a.val(),b);
00372       if (a.val() != value_type(0))
00373   return SimpleFad<ValueT>(a, t, t*b/a.val());
00374       else
00375   return SimpleFad<ValueT>(a, t, value_type(0));
00376     }
00377 
00378     template <typename ValueT>
00379     SimpleFad<ValueT>
00380     atan2(const SimpleFad<ValueT>& a, 
00381     const SimpleFad<ValueT>& b) {
00382       int sz = a.size() >= b.size() ? a.size() : b.size();
00383       SimpleFad<ValueT> c(sz, std::atan2(a.val(), b.val()));
00384       if (a.hasFastAccess() && b.hasFastAccess()) {
00385   ValueT t = a.val()*a.val() + b.val()*b.val();
00386   ValueT t1 = b.val()/t;
00387   ValueT t2 = a.val()/t;
00388   for (int i=0; i<sz; i++)
00389     c.fastAccessDx(i) = 
00390       a.fastAccessDx(i)*t1 - b.fastAccessDx(i)*t2;
00391       }
00392       else if (a.hasFastAccess()) {
00393   ValueT t1 = b.val()/(a.val()*a.val() + b.val()*b.val());
00394   for (int i=0; i<sz; i++)
00395     c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
00396       }
00397       else if (b.hasFastAccess()) {
00398   ValueT t2 = -a.val()/(a.val()*a.val() + b.val()*b.val());
00399   for (int i=0; i<sz; i++)
00400     c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
00401       }
00402 
00403       return c;
00404     }
00405 
00406     template <typename ValueT>
00407     SimpleFad<ValueT>
00408     atan2(const typename SimpleFad<ValueT>::value_type& a, 
00409     const SimpleFad<ValueT>& b) {
00410       return SimpleFad<ValueT>(b, std::atan2(a,b.val()), 
00411              -a/(a*a + b.val()*b.val()));
00412     }
00413 
00414     template <typename ValueT>
00415     SimpleFad<ValueT>
00416     atan2(const SimpleFad<ValueT>& a, 
00417     const typename SimpleFad<ValueT>::value_type& b) {
00418       return SimpleFad<ValueT>(a, std::atan2(a.val(),b), 
00419              b/(a.val()*a.val() + b*b));
00420     }
00421 
00422     template <typename ValueT>
00423     SimpleFad<ValueT>
00424     max(const SimpleFad<ValueT>& a, 
00425   const SimpleFad<ValueT>& b) {
00426       int sz = a.size() >= b.size() ? a.size() : b.size();
00427       SimpleFad<ValueT> c(sz, std::max(a.val(), b.val()));
00428       if (a.hasFastAccess() && b.hasFastAccess()) {
00429   if (a.val() >= b.val())
00430     for (int i=0; i<sz; i++)
00431       c.fastAccessDx(i) = a.fastAccessDx(i);
00432   else
00433     for (int i=0; i<sz; i++)
00434       c.fastAccessDx(i) = b.fastAccessDx(i);
00435       }
00436       else if (a.hasFastAccess()) {
00437   if (a.val() >= b.val())
00438     for (int i=0; i<sz; i++)
00439       c.fastAccessDx(i) = a.fastAccessDx(i);
00440   else
00441     for (int i=0; i<sz; i++)
00442       c.fastAccessDx(i) = 0.0;
00443       }
00444       else if (b.hasFastAccess()) {
00445   if (a.val() >= b.val())
00446     for (int i=0; i<sz; i++)
00447       c.fastAccessDx(i) = 0.0;
00448   else
00449     for (int i=0; i<sz; i++)
00450       c.fastAccessDx(i) = b.fastAccessDx(i);
00451       }
00452 
00453       return c;
00454     }
00455 
00456     template <typename ValueT>
00457     SimpleFad<ValueT>
00458     max(const typename SimpleFad<ValueT>::value_type& a, 
00459   const SimpleFad<ValueT>& b) {
00460       SimpleFad<ValueT> c(b.size(), std::max(a, b.val()));
00461       if (a >= b.val())
00462   for (int i=0; i<c.size(); i++)
00463     c.fastAccessDx(i) = 0.0;
00464       else
00465   for (int i=0; i<c.size(); i++)
00466     c.fastAccessDx(i) = b.fastAccessDx(i);
00467 
00468       return c;
00469     }
00470 
00471     template <typename ValueT>
00472     SimpleFad<ValueT>
00473     max(const SimpleFad<ValueT>& a, 
00474   const typename SimpleFad<ValueT>::value_type& b) {
00475       SimpleFad<ValueT> c(a.size(), std::max(a.val(), b));
00476       if (a.val() >= b)
00477   for (int i=0; i<c.size(); i++)
00478     c.fastAccessDx(i) = a.fastAccessDx(i);
00479       else
00480   for (int i=0; i<c.size(); i++)
00481     c.fastAccessDx(i) = 0.0;
00482 
00483       return c;
00484     }
00485 
00486     template <typename ValueT>
00487     SimpleFad<ValueT>
00488     min(const SimpleFad<ValueT>& a, 
00489   const SimpleFad<ValueT>& b) {
00490       int sz = a.size() >= b.size() ? a.size() : b.size();
00491       SimpleFad<ValueT> c(sz, std::min(a.val(), b.val()));
00492       if (a.hasFastAccess() && b.hasFastAccess()) {
00493   if (a.val() <= b.val())
00494     for (int i=0; i<sz; i++)
00495       c.fastAccessDx(i) = a.fastAccessDx(i);
00496   else
00497     for (int i=0; i<sz; i++)
00498       c.fastAccessDx(i) = b.fastAccessDx(i);
00499       }
00500       else if (a.hasFastAccess()) {
00501   if (a.val() <= b.val())
00502     for (int i=0; i<sz; i++)
00503       c.fastAccessDx(i) = a.fastAccessDx(i);
00504   else
00505     for (int i=0; i<sz; i++)
00506       c.fastAccessDx(i) = 0.0;
00507       }
00508       else if (b.hasFastAccess()) {
00509   if (a.val() <= b.val())
00510     for (int i=0; i<sz; i++)
00511       c.fastAccessDx(i) = 0.0;
00512   else
00513     for (int i=0; i<sz; i++)
00514       c.fastAccessDx(i) = b.fastAccessDx(i);
00515       }
00516 
00517       return c;
00518     }
00519 
00520     template <typename ValueT>
00521     SimpleFad<ValueT>
00522     min(const typename SimpleFad<ValueT>::value_type& a, 
00523   const SimpleFad<ValueT>& b) {
00524       SimpleFad<ValueT> c(b.size(), std::min(a, b.val()));
00525       if (a <= b.val())
00526   for (int i=0; i<c.size(); i++)
00527     c.fastAccessDx(i) = 0.0;
00528       else
00529   for (int i=0; i<c.size(); i++)
00530     c.fastAccessDx(i) = b.fastAccessDx(i);
00531 
00532       return c;
00533     }
00534 
00535     template <typename ValueT>
00536     SimpleFad<ValueT>
00537     min(const SimpleFad<ValueT>& a, 
00538   const typename SimpleFad<ValueT>::value_type& b) {
00539       SimpleFad<ValueT> c(a.size(), std::min(a.val(), b));
00540       if (a.val() <= b)
00541   for (int i=0; i<c.size(); i++)
00542     c.fastAccessDx(i) = a.fastAccessDx(i);
00543       else
00544   for (int i=0; i<c.size(); i++)
00545     c.fastAccessDx(i) = 0.0;
00546 
00547       return c;
00548     }
00549 
00550   } // namespace Fad
00551 
00552 } // namespace Sacado
00553 
00554     //-------------------------- Relational Operators -----------------------
00555 
00556 #define FAD_RELOP_MACRO(OP)           \
00557 namespace Sacado {              \
00558   namespace Fad {             \
00559     template <typename ValueT>            \
00560     inline bool               \
00561     operator OP (const SimpleFad<ValueT>& a,        \
00562      const SimpleFad<ValueT>& b)        \
00563     {                 \
00564       return a.val() OP b.val();          \
00565     }                 \
00566                   \
00567     template <typename ValueT>            \
00568     inline bool               \
00569     operator OP (const ValueT& a,         \
00570      const SimpleFad<ValueT>& b)        \
00571     {                 \
00572       return a OP b.val();            \
00573     }                 \
00574                   \
00575     template <typename ValueT>            \
00576     inline bool               \
00577     operator OP (const SimpleFad<ValueT>& a,        \
00578      const ValueT& b)         \
00579     {                 \
00580       return a.val() OP b;            \
00581     }                 \
00582   }                 \
00583 }
00584 
00585 FAD_RELOP_MACRO(==)
00586 FAD_RELOP_MACRO(!=)
00587 FAD_RELOP_MACRO(<)
00588 FAD_RELOP_MACRO(>)
00589 FAD_RELOP_MACRO(<=)
00590 FAD_RELOP_MACRO(>=)
00591 FAD_RELOP_MACRO(<<=)
00592 FAD_RELOP_MACRO(>>=)
00593 FAD_RELOP_MACRO(&)
00594 FAD_RELOP_MACRO(|)
00595 
00596 #undef FAD_RELOP_MACRO
00597 
00598 namespace Sacado {
00599 
00600   namespace Fad {
00601 
00602     template <typename ValueT>
00603     inline bool operator ! (const SimpleFad<ValueT>& a) 
00604     {
00605       return ! a.val();
00606     }
00607 
00608   } // namespace Fad
00609 
00610 } // namespace Sacado
00611 
00612 //-------------------------- I/O Operators -----------------------
00613 
00614 namespace Sacado {
00615 
00616   namespace Fad {
00617 
00618     template <typename ValueT>
00619     std::ostream& operator << (std::ostream& os, 
00620              const SimpleFad<ValueT>& x) {
00621       os << x.val() << " [";
00622       
00623       for (int i=0; i< x.size(); i++) {
00624         os << " " << x.dx(i);
00625       }
00626 
00627       os << " ]";
00628       return os;
00629     }
00630 
00631  } // namespace Fad
00632 
00633 } // namespace Sacado
00634 
00635 #endif // SACADO_FAD_SIMPLEFADOPS_HPP
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines