src/float/misc/cl_F_decode.cc

   1 // decode_float().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cln/float.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cl_SF.h"
  13 #include "cl_FF.h"
  14 #include "cl_DF.h"
  15 #include "cl_LF.h"
  16 #include "cl_LF_impl.h"
  17 #include "cl_I.h"
  18 #include "cl_F.h"
  19
  20 namespace cln {
  21
  22 inline const decoded_float decode_float (const cl_SF& x)
  23 {
  24         // x entpacken:
  25         var cl_signean sign;
  26         var sintL exp;
  27         var uint32 mant;
  28         SF_decode(x, { return decoded_float(SF_0, 0, SF_1); },
  29                      sign=,exp=,mant=
  30                  );
  31         return decoded_float(
  32                 encode_SF(0,0,mant), // (-1)^0 * 2^0 * m erzeugen
  33                 L_to_FN(exp), // e als Fixnum
  34                 encode_SF(sign,1,bit(SF_mant_len)) // (-1)^s erzeugen
  35                );
  36 }
  37
  38 inline const decoded_float decode_float (const cl_FF& x)
  39 {
  40         // x entpacken:
  41         var cl_signean sign;
  42         var sintL exp;
  43         var uint32 mant;
  44         FF_decode(x, { return decoded_float(cl_FF_0, 0, cl_FF_1); },
  45                      sign=,exp=,mant=
  46                  );
  47         return decoded_float(
  48                 encode_FF(0,0,mant), // (-1)^0 * 2^0 * m erzeugen
  49                 L_to_FN(exp), // e als Fixnum
  50                 encode_FF(sign,1,bit(FF_mant_len)) // (-1)^s erzeugen
  51                );
  52 }
  53
  54 inline const decoded_float decode_float (const cl_DF& x)
  55 {
  56         // x entpacken:
  57         var cl_signean sign;
  58         var sintL exp;
  59 #if (cl_word_size==64)
  60         var uint64 mant;
  61         DF_decode(x, { return decoded_float(cl_DF_0, 0, cl_DF_1); },
  62                      sign=,exp=,mant=
  63                  );
  64         return decoded_float(
  65                 encode_DF(0,0,mant), // (-1)^0 * 2^0 * m erzeugen
  66                 L_to_FN(exp), // e als Fixnum
  67                 encode_DF(sign,1,bit(DF_mant_len)) // (-1)^s erzeugen
  68                );
  69 #else
  70         var uint32 manthi;
  71         var uint32 mantlo;
  72         DF_decode2(x, { return decoded_float(cl_DF_0, 0, cl_DF_1); },
  73                       sign=,exp=,manthi=,mantlo=
  74                   );
  75         return decoded_float(
  76                 encode_DF(0,0,manthi,mantlo), // (-1)^0 * 2^0 * m erzeugen
  77                 L_to_FN(exp), // e als Fixnum
  78                 encode_DF(sign,1,bit(DF_mant_len-32),0) // (-1)^s erzeugen
  79                );
  80 #endif
  81 }
  82
  83 inline const decoded_float decode_float (const cl_LF& x)
  84 {
  85         // x entpacken:
  86         var cl_signean sign;
  87         var sintL exp;
  88         var uintC mantlen;
  89         var const uintD* mantMSDptr;
  90         LF_decode(x, { return decoded_float(x, 0, encode_LF1(mantlen)); },
  91                      sign=,exp=,mantMSDptr=,mantlen=,);
  92         return decoded_float(
  93                 encode_LFu(0,0+LF_exp_mid,mantMSDptr,mantlen), // (-1)^0 * 2^0 * m erzeugen
  94                 L_to_I(exp), // e als Fixnum
  95                 encode_LF1s(sign,mantlen) // (-1)^s erzeugen
  96                );
  97 }
  98
  99 const decoded_float decode_float (const cl_F& x)
 100 {
 101         floatcase(x
 102         ,       return decode_float(x);
 103         ,       return decode_float(x);
 104         ,       return decode_float(x);
 105         ,       return decode_float(x);
 106         );
 107 }
 108
 109 }  // namespace cln