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       if (a.hasFastAccess() && b.hasFastAccess()) {
00327   ValueT t1 = c.val()*b.val()/a.val();
00328   ValueT t2 = c.val()*std::log(a.val());
00329   for (int i=0; i<sz; i++)
00330     c.fastAccessDx(i) = 
00331       a.fastAccessDx(i)*t1 + b.fastAccessDx(i)*t2;
00332       }
00333       else if (a.hasFastAccess()) {
00334   ValueT t1 = c.val()*b.val()/a.val();
00335   for (int i=0; i<sz; i++)
00336     c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
00337       }
00338       else if (b.hasFastAccess()) {
00339   ValueT t2 = c.val()*std::log(a.val());
00340   for (int i=0; i<sz; i++)
00341     c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
00342       }
00343 
00344       return c;
00345     }
00346 
00347     template <typename ValueT>
00348     SimpleFad<ValueT>
00349     pow(const typename SimpleFad<ValueT>::value_type& a, 
00350   const SimpleFad<ValueT>& b) {
00351       ValueT t = std::pow(a,b.val());
00352       return SimpleFad<ValueT>(b, t, t*std::log(a));
00353     }
00354 
00355     template <typename ValueT>
00356     SimpleFad<ValueT>
00357     pow(const SimpleFad<ValueT>& a, 
00358   const typename SimpleFad<ValueT>::value_type& b) {
00359       ValueT t = std::pow(a.val(),b);
00360       return SimpleFad<ValueT>(a, t, t*b/a.val());
00361     }
00362 
00363     template <typename ValueT>
00364     SimpleFad<ValueT>
00365     atan2(const SimpleFad<ValueT>& a, 
00366     const SimpleFad<ValueT>& b) {
00367       int sz = a.size() >= b.size() ? a.size() : b.size();
00368       SimpleFad<ValueT> c(sz, std::atan2(a.val(), b.val()));
00369       if (a.hasFastAccess() && b.hasFastAccess()) {
00370   ValueT t = a.val()*a.val() + b.val()*b.val();
00371   ValueT t1 = b.val()/t;
00372   ValueT t2 = a.val()/t;
00373   for (int i=0; i<sz; i++)
00374     c.fastAccessDx(i) = 
00375       a.fastAccessDx(i)*t1 - b.fastAccessDx(i)*t2;
00376       }
00377       else if (a.hasFastAccess()) {
00378   ValueT t1 = b.val()/(a.val()*a.val() + b.val()*b.val());
00379   for (int i=0; i<sz; i++)
00380     c.fastAccessDx(i) = a.fastAccessDx(i)*t1;
00381       }
00382       else if (b.hasFastAccess()) {
00383   ValueT t2 = -a.val()/(a.val()*a.val() + b.val()*b.val());
00384   for (int i=0; i<sz; i++)
00385     c.fastAccessDx(i) = b.fastAccessDx(i)*t2;
00386       }
00387 
00388       return c;
00389     }
00390 
00391     template <typename ValueT>
00392     SimpleFad<ValueT>
00393     atan2(const typename SimpleFad<ValueT>::value_type& a, 
00394     const SimpleFad<ValueT>& b) {
00395       return SimpleFad<ValueT>(b, std::atan2(a,b.val()), 
00396              -a/(a*a + b.val()*b.val()));
00397     }
00398 
00399     template <typename ValueT>
00400     SimpleFad<ValueT>
00401     atan2(const SimpleFad<ValueT>& a, 
00402     const typename SimpleFad<ValueT>::value_type& b) {
00403       return SimpleFad<ValueT>(a, std::atan2(a.val(),b), 
00404              b/(a.val()*a.val() + b*b));
00405     }
00406 
00407     template <typename ValueT>
00408     SimpleFad<ValueT>
00409     max(const SimpleFad<ValueT>& a, 
00410   const SimpleFad<ValueT>& b) {
00411       int sz = a.size() >= b.size() ? a.size() : b.size();
00412       SimpleFad<ValueT> c(sz, std::max(a.val(), b.val()));
00413       if (a.hasFastAccess() && b.hasFastAccess()) {
00414   if (a.val() >= b.val())
00415     for (int i=0; i<sz; i++)
00416       c.fastAccessDx(i) = a.fastAccessDx(i);
00417   else
00418     for (int i=0; i<sz; i++)
00419       c.fastAccessDx(i) = b.fastAccessDx(i);
00420       }
00421       else if (a.hasFastAccess()) {
00422   if (a.val() >= b.val())
00423     for (int i=0; i<sz; i++)
00424       c.fastAccessDx(i) = a.fastAccessDx(i);
00425   else
00426     for (int i=0; i<sz; i++)
00427       c.fastAccessDx(i) = 0.0;
00428       }
00429       else if (b.hasFastAccess()) {
00430   if (a.val() >= b.val())
00431     for (int i=0; i<sz; i++)
00432       c.fastAccessDx(i) = 0.0;
00433   else
00434     for (int i=0; i<sz; i++)
00435       c.fastAccessDx(i) = b.fastAccessDx(i);
00436       }
00437 
00438       return c;
00439     }
00440 
00441     template <typename ValueT>
00442     SimpleFad<ValueT>
00443     max(const typename SimpleFad<ValueT>::value_type& a, 
00444   const SimpleFad<ValueT>& b) {
00445       SimpleFad<ValueT> c(b.size(), std::max(a, b.val()));
00446       if (a >= b.val())
00447   for (int i=0; i<c.size(); i++)
00448     c.fastAccessDx(i) = 0.0;
00449       else
00450   for (int i=0; i<c.size(); i++)
00451     c.fastAccessDx(i) = b.fastAccessDx(i);
00452 
00453       return c;
00454     }
00455 
00456     template <typename ValueT>
00457     SimpleFad<ValueT>
00458     max(const SimpleFad<ValueT>& a, 
00459   const typename SimpleFad<ValueT>::value_type& b) {
00460       SimpleFad<ValueT> c(a.size(), std::max(a.val(), b));
00461       if (a.val() >= b)
00462   for (int i=0; i<c.size(); i++)
00463     c.fastAccessDx(i) = a.fastAccessDx(i);
00464       else
00465   for (int i=0; i<c.size(); i++)
00466     c.fastAccessDx(i) = 0.0;
00467 
00468       return c;
00469     }
00470 
00471     template <typename ValueT>
00472     SimpleFad<ValueT>
00473     min(const SimpleFad<ValueT>& a, 
00474   const SimpleFad<ValueT>& b) {
00475       int sz = a.size() >= b.size() ? a.size() : b.size();
00476       SimpleFad<ValueT> c(sz, std::min(a.val(), b.val()));
00477       if (a.hasFastAccess() && b.hasFastAccess()) {
00478   if (a.val() <= b.val())
00479     for (int i=0; i<sz; i++)
00480       c.fastAccessDx(i) = a.fastAccessDx(i);
00481   else
00482     for (int i=0; i<sz; i++)
00483       c.fastAccessDx(i) = b.fastAccessDx(i);
00484       }
00485       else if (a.hasFastAccess()) {
00486   if (a.val() <= b.val())
00487     for (int i=0; i<sz; i++)
00488       c.fastAccessDx(i) = a.fastAccessDx(i);
00489   else
00490     for (int i=0; i<sz; i++)
00491       c.fastAccessDx(i) = 0.0;
00492       }
00493       else if (b.hasFastAccess()) {
00494   if (a.val() <= b.val())
00495     for (int i=0; i<sz; i++)
00496       c.fastAccessDx(i) = 0.0;
00497   else
00498     for (int i=0; i<sz; i++)
00499       c.fastAccessDx(i) = b.fastAccessDx(i);
00500       }
00501 
00502       return c;
00503     }
00504 
00505     template <typename ValueT>
00506     SimpleFad<ValueT>
00507     min(const typename SimpleFad<ValueT>::value_type& a, 
00508   const SimpleFad<ValueT>& b) {
00509       SimpleFad<ValueT> c(b.size(), std::min(a, b.val()));
00510       if (a <= b.val())
00511   for (int i=0; i<c.size(); i++)
00512     c.fastAccessDx(i) = 0.0;
00513       else
00514   for (int i=0; i<c.size(); i++)
00515     c.fastAccessDx(i) = b.fastAccessDx(i);
00516 
00517       return c;
00518     }
00519 
00520     template <typename ValueT>
00521     SimpleFad<ValueT>
00522     min(const SimpleFad<ValueT>& a, 
00523   const typename SimpleFad<ValueT>::value_type& b) {
00524       SimpleFad<ValueT> c(a.size(), std::min(a.val(), b));
00525       if (a.val() <= b)
00526   for (int i=0; i<c.size(); i++)
00527     c.fastAccessDx(i) = a.fastAccessDx(i);
00528       else
00529   for (int i=0; i<c.size(); i++)
00530     c.fastAccessDx(i) = 0.0;
00531 
00532       return c;
00533     }
00534 
00535   } // namespace Fad
00536 
00537 } // namespace Sacado
00538 
00539     //-------------------------- Relational Operators -----------------------
00540 
00541 #define FAD_RELOP_MACRO(OP)           \
00542 namespace Sacado {              \
00543   namespace Fad {             \
00544     template <typename ValueT>            \
00545     inline bool               \
00546     operator OP (const SimpleFad<ValueT>& a,        \
00547      const SimpleFad<ValueT>& b)        \
00548     {                 \
00549       return a.val() OP b.val();          \
00550     }                 \
00551                   \
00552     template <typename ValueT>            \
00553     inline bool               \
00554     operator OP (const ValueT& a,         \
00555      const SimpleFad<ValueT>& b)        \
00556     {                 \
00557       return a OP b.val();            \
00558     }                 \
00559                   \
00560     template <typename ValueT>            \
00561     inline bool               \
00562     operator OP (const SimpleFad<ValueT>& a,        \
00563      const ValueT& b)         \
00564     {                 \
00565       return a.val() OP b;            \
00566     }                 \
00567   }                 \
00568 }
00569 
00570 FAD_RELOP_MACRO(==)
00571 FAD_RELOP_MACRO(!=)
00572 FAD_RELOP_MACRO(<)
00573 FAD_RELOP_MACRO(>)
00574 FAD_RELOP_MACRO(<=)
00575 FAD_RELOP_MACRO(>=)
00576 FAD_RELOP_MACRO(<<=)
00577 FAD_RELOP_MACRO(>>=)
00578 FAD_RELOP_MACRO(&)
00579 FAD_RELOP_MACRO(|)
00580 
00581 #undef FAD_RELOP_MACRO
00582 
00583 namespace Sacado {
00584 
00585   namespace Fad {
00586 
00587     template <typename ValueT>
00588     inline bool operator ! (const SimpleFad<ValueT>& a) 
00589     {
00590       return ! a.val();
00591     }
00592 
00593   } // namespace Fad
00594 
00595 } // namespace Sacado
00596 
00597 //-------------------------- I/O Operators -----------------------
00598 
00599 namespace Sacado {
00600 
00601   namespace Fad {
00602 
00603     template <typename ValueT>
00604     std::ostream& operator << (std::ostream& os, 
00605              const SimpleFad<ValueT>& x) {
00606       os << x.val() << " [";
00607       
00608       for (int i=0; i< x.size(); i++) {
00609         os << " " << x.dx(i);
00610       }
00611 
00612       os << " ]";
00613       return os;
00614     }
00615 
00616  } // namespace Fad
00617 
00618 } // namespace Sacado
00619 
00620 #endif // SACADO_FAD_SIMPLEFADOPS_HPP

Generated on Wed May 12 21:39:34 2010 for Sacado Package Browser (Single Doxygen Collection) by  doxygen 1.4.7