Geant4 Cross Reference |
1 // -*- C++ -*- 1 // -*- C++ -*- 2 // 2 // 3 // ------------------------------------------- 3 // ----------------------------------------------------------------------- 4 // Hep Random 4 // Hep Random 5 // --- DoubConv --- 5 // --- DoubConv --- 6 // class header file 6 // class header file 7 // ------------------------------------------- 7 // ----------------------------------------------------------------------- 8 // 8 // 9 #ifndef DOUBCONV_HH 9 #ifndef DOUBCONV_HH 10 #define DOUBCONV_HH 10 #define DOUBCONV_HH 11 11 12 #include <string> 12 #include <string> 13 #include <vector> 13 #include <vector> 14 #include <exception> 14 #include <exception> 15 #include "CLHEP/Utility/thread_local.h" 15 #include "CLHEP/Utility/thread_local.h" 16 16 17 namespace CLHEP { 17 namespace CLHEP { 18 18 19 class DoubConvException : public std::excepti 19 class DoubConvException : public std::exception { 20 public: 20 public: 21 DoubConvException(const std::string & w) thr 21 DoubConvException(const std::string & w) throw() : msg(w) {} 22 ~DoubConvException() throw() {} 22 ~DoubConvException() throw() {} 23 const char* what() const throw() { return ms 23 const char* what() const throw() { return msg.c_str(); } 24 private: 24 private: 25 std::string msg; 25 std::string msg; 26 }; 26 }; 27 27 28 class DoubConv { 28 class DoubConv { 29 public: 29 public: 30 30 31 // dto2longs(d) returns (in a vector) two un 31 // dto2longs(d) returns (in a vector) two unsigned longs string containing the 32 // representation of its double input. This 32 // representation of its double input. This is byte-ordering 33 // independant, and depends for complete por 33 // independant, and depends for complete portability ONLY on adherance 34 // to the IEEE 754 standard for 64-bit float 34 // to the IEEE 754 standard for 64-bit floating point representation. 35 // The first unsigned long contains the high 35 // The first unsigned long contains the high-order bits in IEEE; thus 36 // 1.0 will always be 0x3FF00000, 00000000 36 // 1.0 will always be 0x3FF00000, 00000000 37 static std::vector<unsigned long> dto2longs( 37 static std::vector<unsigned long> dto2longs(double d); 38 38 39 // longs2double (v) returns a double contain 39 // longs2double (v) returns a double containing the value represented by its 40 // input, which must be a vector containing 40 // input, which must be a vector containing 2 unsigned longs. 41 // The input is taken to be the representati 41 // The input is taken to be the representation according to 42 // the IEEE 754 standard for a 64-bit floati 42 // the IEEE 754 standard for a 64-bit floating point number, whose value 43 // is returned as a double. The byte-orderi 43 // is returned as a double. The byte-ordering of the double result is, 44 // of course, tailored to the proper byte-or 44 // of course, tailored to the proper byte-ordering for the system. 45 static double longs2double (const std::vecto 45 static double longs2double (const std::vector<unsigned long> & v); 46 46 47 // dtox(d) returns a 16-character string con 47 // dtox(d) returns a 16-character string containing the (zero-filled) hex 48 // representation of its double input. This 48 // representation of its double input. This is byte-ordering 49 // independant, and depends for complete por 49 // independant, and depends for complete portability ONLY on adherance 50 // to the IEEE 754 standard for 64-bit float 50 // to the IEEE 754 standard for 64-bit floating point representation. 51 static std::string d2x(double d); 51 static std::string d2x(double d); 52 52 53 private: 53 private: 54 union DB8 { 54 union DB8 { 55 unsigned char b[8]; 55 unsigned char b[8]; 56 double d; 56 double d; 57 }; 57 }; 58 static void fill_byte_order (); 58 static void fill_byte_order (); 59 static CLHEP_THREAD_LOCAL bool byte_order_kn 59 static CLHEP_THREAD_LOCAL bool byte_order_known; 60 static CLHEP_THREAD_LOCAL int byte_order[8] 60 static CLHEP_THREAD_LOCAL int byte_order[8]; 61 // Meaning of byte_order: The first (high 61 // Meaning of byte_order: The first (high-order in IEEE 754) byte to 62 // output (or the high-order byte of the f 62 // output (or the high-order byte of the first unsigned long) 63 // is of db.b[byte_order[0]]. Thus the i 63 // is of db.b[byte_order[0]]. Thus the index INTO byte_order 64 // is a position in the IEEE representatio 64 // is a position in the IEEE representation of the double, and the value 65 // of byte_order[k] is an offset in the me 65 // of byte_order[k] is an offset in the memory representation of the 66 // double. 66 // double. 67 }; 67 }; 68 68 69 69 70 } 70 } 71 71 72 #endif // DOUBCONV_HH 72 #endif // DOUBCONV_HH 73 73