src/Emu/Utility/Math.h

説明を見る。
00001 // 
00002 // Copyright (c) 2005-2008 Kenichi Watanabe.
00003 // Copyright (c) 2005-2008 Yasuhiro Watari.
00004 // Copyright (c) 2005-2008 Hironori Ichibayashi.
00005 // Copyright (c) 2008-2009 Kazuo Horio.
00006 // Copyright (c) 2009-2013 Naruki Kurata.
00007 // Copyright (c) 2005-2013 Ryota Shioya.
00008 // Copyright (c) 2005-2013 Masahiro Goshima.
00009 // 
00010 // This software is provided 'as-is', without any express or implied
00011 // warranty. In no event will the authors be held liable for any damages
00012 // arising from the use of this software.
00013 // 
00014 // Permission is granted to anyone to use this software for any purpose,
00015 // including commercial applications, and to alter it and redistribute it
00016 // freely, subject to the following restrictions:
00017 // 
00018 // 1. The origin of this software must not be misrepresented; you must not
00019 // claim that you wrote the original software. If you use this software
00020 // in a product, an acknowledgment in the product documentation would be
00021 // appreciated but is not required.
00022 // 
00023 // 2. Altered source versions must be plainly marked as such, and must not be
00024 // misrepresented as being the original software.
00025 // 
00026 // 3. This notice may not be removed or altered from any source
00027 // distribution.
00028 // 
00029 // 
00030 
00031 
00032 #ifndef EMU_UTILITY_MATH_H
00033 #define EMU_UTILITY_MATH_H
00034 
00035 
00036 namespace Onikiri {
00037 namespace EmulatorUtility {
00038 
00039 template < typename T >
00040 static bool IsNAN( T value )
00041 {
00042     return boost::math::isnan( value );
00043 }
00044 
00045 // generate signed/unsigned type of T
00046 // ex) signed_unsigned_type<int, false>::type is unsigned int
00047 template <typename T, bool Signed>
00048     struct signed_unsigned_type;
00049 
00050 template <typename T>
00051 struct signed_type
00052 {
00053     typedef typename signed_unsigned_type<T, true>::type type;
00054 };
00055 
00056 template <typename T>
00057 struct unsigned_type
00058 {
00059     typedef typename signed_unsigned_type<T, false>::type type;
00060 };
00061 
00062 #define IMPLEMENT_SIGNED_UNSIGNED_TYPE(Type)        \
00063 template <>                                         \
00064 struct signed_unsigned_type<signed Type, true> {    \
00065     typedef signed Type type;                       \
00066 };                                                  \
00067 template <>                                         \
00068 struct signed_unsigned_type<signed Type, false> {   \
00069     typedef unsigned Type type;                     \
00070 };                                                  \
00071 template <>                                         \
00072 struct signed_unsigned_type<unsigned Type, true> {  \
00073     typedef signed Type type;                       \
00074 };                                                  \
00075 template <>                                         \
00076 struct signed_unsigned_type<unsigned Type, false> { \
00077     typedef unsigned Type type;                     \
00078 };
00079 #define IMPLEMENT_SIGNED_UNSIGNED_TYPE_FLOAT(Type)  \
00080 template <bool Sign>                                \
00081 struct signed_unsigned_type<Type, Sign> {           \
00082     typedef Type type;                              \
00083 };
00084 
00085 IMPLEMENT_SIGNED_UNSIGNED_TYPE(char)
00086 IMPLEMENT_SIGNED_UNSIGNED_TYPE(short)
00087 IMPLEMENT_SIGNED_UNSIGNED_TYPE(int)
00088 IMPLEMENT_SIGNED_UNSIGNED_TYPE(long)
00089 IMPLEMENT_SIGNED_UNSIGNED_TYPE(long long)
00090 IMPLEMENT_SIGNED_UNSIGNED_TYPE_FLOAT(float)
00091 IMPLEMENT_SIGNED_UNSIGNED_TYPE_FLOAT(double)
00092 IMPLEMENT_SIGNED_UNSIGNED_TYPE_FLOAT(long double)
00093 
00094 #undef IMPLEMENT_SIGNED_UNSIGNED_TYPE
00095 #undef IMPLEMENT_SIGNED_UNSIGNED_TYPE_FLOAT
00096 
00097 // cast 'T' to 'unsigned T'
00098 template <typename T>
00099 inline typename unsigned_type<T>::type cast_to_unsigned(T x)
00100 {
00101     return static_cast< typename unsigned_type<T>::type > (x); 
00102 }
00103 
00104 // cast 'T' to 'signed T'
00105 template <typename T>
00106 inline typename signed_type<T>::type cast_to_signed(T x)
00107 {
00108     return static_cast< typename signed_type<T>::type > (x);
00109 }
00110 
00111 } // namespace EmulatorUtility {
00112 } // namespace Onikiri
00113 
00114 #endif  // #ifndef EMU_UTILITY_MATH_H
00115 
00116 

Onikiri2に対してTue Jun 18 14:34:20 2013に生成されました。  doxygen 1.4.7