Teuchos Package Browser (Single Doxygen Collection) Version of the Day
Teuchos_MatrixMarket_SetScientific.hpp
Go to the documentation of this file.
00001 // @HEADER
00002 // ***********************************************************************
00003 //
00004 //          Tpetra: Templated Linear Algebra Services Package
00005 //                 Copyright (2008) Sandia Corporation
00006 //
00007 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
00008 // the U.S. Government retains certain rights in this software.
00009 //
00010 // Redistribution and use in source and binary forms, with or without
00011 // modification, are permitted provided that the following conditions are
00012 // met:
00013 //
00014 // 1. Redistributions of source code must retain the above copyright
00015 // notice, this list of conditions and the following disclaimer.
00016 //
00017 // 2. Redistributions in binary form must reproduce the above copyright
00018 // notice, this list of conditions and the following disclaimer in the
00019 // documentation and/or other materials provided with the distribution.
00020 //
00021 // 3. Neither the name of the Corporation nor the names of the
00022 // contributors may be used to endorse or promote products derived from
00023 // this software without specific prior written permission.
00024 //
00025 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
00026 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00027 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
00028 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
00029 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00030 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00031 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00032 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00033 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00034 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00035 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00036 //
00037 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
00038 //
00039 // ************************************************************************
00040 // @HEADER
00041 
00042 #ifndef __Teuchos_MatrixMarket_SetScientific_hpp
00043 #define __Teuchos_MatrixMarket_SetScientific_hpp
00044 
00045 #include <Teuchos_ConfigDefs.hpp>
00046 #include <Teuchos_as.hpp>
00047 #include <Teuchos_ScalarTraits.hpp>
00048 #include <string>
00049 
00050 
00051 namespace Teuchos {
00052   namespace MatrixMarket {
00053     namespace details {
00078       template<class Scalar>
00079       class SetScientific {
00080       public:
00082         typedef Scalar scalar_type;
00083 
00088         SetScientific (std::ostream& out) :
00089           out_ (out), originalFlags_ (out.flags())
00090         {
00091           typedef Teuchos::ScalarTraits<scalar_type> STS;
00092           typedef typename STS::magnitudeType magnitude_type;
00093           typedef Teuchos::ScalarTraits<magnitude_type> STM;
00094 
00095           // Print floating-point values in scientific notation.
00096           out << std::scientific;
00097 
00098           // We're writing decimal digits, so compute the number of
00099           // digits we need to get reasonable accuracy when reading
00100           // values back in.
00101           //
00102           // There is actually an algorithm, due to Guy Steele (yes,
00103           // Java's Guy Steele) et al., for idempotent printing of
00104           // finite-length floating-point values.  We should actually
00105           // implement that algorithm, but I don't have time for that
00106           // now.  Currently, I just print no more than (one decimal
00107           // digit more than (the number of decimal digits justified
00108           // by the precision of magnitude_type)).
00109           //
00110           // We need to use STM's log10() rather than (say) std::log10
00111           // here, because STM::base() returns a magnitude_type, not
00112           // one of C++'s standard integer types.
00113           const magnitude_type numDecDigits = STM::t() * STM::log10 (STM::base());
00114 
00115           // Round and add one.  The cast to int should not overflow
00116           // unless STM::t() is _extremely_ large, so we don't need to
00117           // check for that case here.
00118           const magnitude_type one = STM::one();
00119           const magnitude_type two = one + one;
00120           // Cast from magnitude_type to int, since std::ostream's
00121           // precision() method expects an int input.
00122           const int prec = 1 + Teuchos::as<int> ((two*numDecDigits + one) / two);
00123 
00124           // Set the number of (decimal) digits after the decimal
00125           // point to print.
00126           out.precision (prec);
00127         }
00128 
00134         ~SetScientific () {
00135           out_.flags (originalFlags_);
00136         }
00137 
00138       private:
00140         std::ostream& out_;
00141 
00143         std::ios_base::fmtflags originalFlags_;
00144       };
00145 
00146       // Specialization for Scalar=int.  Specializations for built-in
00147       // integer types let Tpetra::MatrixMarket::Reader or
00148       // Tpetra::MatrixMarket::Writer work with a Tpetra::CrsMatrix
00149       // whose Scalar template parameter is a built-in integer type.
00150       // These specializations are trivial because there are no
00151       // decimal digits to print.
00152       template<>
00153       class SetScientific<int> {
00154       public:
00155         typedef int scalar_type;
00156         SetScientific (std::ostream& out) {}
00157         ~SetScientific () {}
00158       };
00159 
00160       // Specialization for Scalar=unsigned int.
00161       template<>
00162       class SetScientific<unsigned int> {
00163       public:
00164         typedef unsigned int scalar_type;
00165         SetScientific (std::ostream& out) {}
00166         ~SetScientific () {}
00167       };
00168 
00169       // Specialization for Scalar=long.
00170       template<>
00171       class SetScientific<long> {
00172       public:
00173         typedef long scalar_type;
00174         SetScientific (std::ostream& out) {}
00175         ~SetScientific () {}
00176       };
00177 
00178       // Specialization for Scalar=unsigned long.
00179       template<>
00180       class SetScientific<unsigned long> {
00181       public:
00182         typedef unsigned long scalar_type;
00183         SetScientific (std::ostream& out) {}
00184         ~SetScientific () {}
00185       };
00186 
00187 #ifdef HAVE_TEUCHOS_LONG_LONG_INT
00188 
00189       // Specialization for Scalar=long long.
00190       template<>
00191       class SetScientific<long long> {
00192       public:
00193         typedef long long scalar_type;
00194         SetScientific (std::ostream& out) {}
00195         ~SetScientific () {}
00196       };
00197 
00198       // Specialization for Scalar=unsigned long long.
00199       template<>
00200       class SetScientific<unsigned long long> {
00201       public:
00202         typedef unsigned long long scalar_type;
00203         SetScientific (std::ostream& out) {}
00204         ~SetScientific () {}
00205       };
00206 
00207 #endif // HAVE_TEUCHOS_LONG_LONG_INT
00208 
00209 
00210     } // namespace details
00211   } // namespace MatrixMarket
00212 } // namespace Teuchos
00213 
00214 #endif // __Teuchos_MatrixMarket_SetScientific_hpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines