Kokkos Node API and Local Linear Algebra Kernels Version of the Day
Tsqr_ScalarTraits.hpp
00001 //@HEADER
00002 // ************************************************************************
00003 // 
00004 //          Kokkos: Node API and Parallel Node Kernels
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 __TSQR_Tsqr_ScalarTraits_hpp
00043 #define __TSQR_Tsqr_ScalarTraits_hpp
00044 
00045 #include <Tsqr_ConfigDefs.hpp>
00046 
00047 #include <cmath> // std::abs
00048 #include <complex>
00049 
00050 
00051 namespace TSQR {
00052 
00072   template< class Scalar >
00073   class ScalarTraits {
00074   public:
00080     static const bool is_specialized = false;
00081 
00083     static const bool is_complex = false;
00089     typedef Scalar magnitude_type;
00092     static Scalar zero();
00095     static Scalar one();
00096 
00099     static magnitude_type pi();
00100 
00102     inline static Scalar conj (const Scalar& z);
00103 
00105     inline static magnitude_type abs (const Scalar& z);
00106   };
00107 
00108   template<>
00109   class ScalarTraits< double > {
00110   public:
00111     static const bool is_specialized = true;
00112     static const bool is_complex = false;
00113     typedef double magnitude_type;
00114 
00115     static double zero() { return 0.0; }
00116     static double one() { return 1.0; }
00117     static magnitude_type pi() {
00118       // In double precision, 17 digits suffice.  We include 20 just
00119       // for good measure.  Hopefully the C++ compiler won't do a
00120       // stupid thing with them.
00121       return 3.14159265358979323846;
00122     }
00123 
00124     inline static double conj (const double& z) { return z; }
00125     inline static magnitude_type abs (const double& z) {
00126       return std::abs (z);
00127     }
00128   };
00129 
00130   template<>
00131   class ScalarTraits< float > {
00132   public:
00133     static const bool is_specialized = true;
00134     static const bool is_complex = false;
00135     typedef float magnitude_type;
00136 
00137     static float zero() { return 0.0; }
00138     static float one() { return 1.0; }
00139     static magnitude_type pi() {
00140       return 3.14159265358979323846;
00141     }
00142 
00143     inline static float conj (const float& z) { return z; }
00144     inline static magnitude_type abs (const float& z) {
00145       return std::abs (z);
00146     }
00147   };
00148 
00149   template<>
00150   class ScalarTraits< std::complex< double > > {
00151   public:
00152     static const bool is_specialized = true;
00153     static const bool is_complex = true;
00154     typedef double magnitude_type;
00155 
00156     static std::complex<double> zero() { return std::complex<double>(0.0, 0.0); }
00157     static std::complex<double> one()  { return std::complex<double>(1.0, 0.0); }
00158     static magnitude_type pi() { return ScalarTraits< magnitude_type >::pi(); }
00159 
00160     inline static std::complex<double> conj (const std::complex<double>& z) {
00161       return std::conj (z);
00162     }
00163     inline static magnitude_type abs (const std::complex<double>& z) {
00164       return std::abs (z);
00165     }
00166   };
00167 
00168   template<>
00169   class ScalarTraits< std::complex< float > > {
00170   public:
00171     static const bool is_specialized = true;
00172     static const bool is_complex = true;
00173     typedef float magnitude_type;
00174 
00175     static std::complex<float> zero() { return std::complex<float>(0.0, 0.0); }
00176     static std::complex<float> one()  { return std::complex<float>(1.0, 0.0); }
00177     static magnitude_type pi() { return ScalarTraits< magnitude_type >::pi(); }
00178 
00179     inline static std::complex<float> conj (const std::complex<float>& z) {
00180       return std::conj (z);
00181     }
00182     inline static magnitude_type abs (const std::complex<float>& z) {
00183       return std::abs (z);
00184     }
00185   };
00186 
00187 
00188 } // namespace TSQR
00189 
00190 #endif // __TSQR_Tsqr_ScalarTraits_hpp
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends