src/float/dfloat/elem/cl_DF_futrunc.cc

   1 // futruncate().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cl_DF.h"
   8
   9
  10 // Implementation.
  11
  12 namespace cln {
  13
  14 const cl_DF futruncate (const cl_DF& x)
  15 {
  16 // Methode:
  17 // x = 0.0 -> Ergebnis 0.0
  18 // e<=0 -> Ergebnis 1.0 oder -1.0, je nach Vorzeichen von x.
  19 // 1<=e<=52 -> Greife die letzten (53-e) Bits von x heraus.
  20 //             Sind sie alle =0 -> Ergebnis x.
  21 //             Sonst setze sie alle und erhöhe dann die letzte Stelle um 1.
  22 //             Kein Überlauf der 52 Bit -> fertig.
  23 //             Sonst (Ergebnis eine Zweierpotenz): Mantisse := .1000...000,
  24 //               e:=e+1. (Test auf Überlauf wegen e<=53 überflüssig)
  25 // e>=53 -> Ergebnis x.
  26 #if (cl_word_size==64)
  27       var dfloat x_ = TheDfloat(x)->dfloat_value;
  28       var uintL uexp = DF_uexp(x_); // e + DF_exp_mid
  29       if (uexp==0) // 0.0 ?
  30         { return x; }
  31       if (uexp <= DF_exp_mid) // e<=0 ?
  32         { // Exponent auf 1, Mantisse auf .1000...000 setzen.
  33           return ((x_ & bit(63))==0 ? cl_DF_1 : cl_DF_minus1);
  34         }
  35         else
  36         { if (uexp > DF_exp_mid+DF_mant_len) // e > 52 ?
  37             { return x; }
  38             else
  39             { var uint64 mask = // Bitmaske: Bits 52-e..0 gesetzt, alle anderen gelöscht
  40                 bit(DF_mant_len+1+DF_exp_mid-uexp)-1;
  41               if ((x_ & mask)==0) // alle diese Bits =0 ?
  42                 { return x; }
  43               return allocate_dfloat
  44                 ((x_ | mask) // alle diese Bits setzen
  45                  + 1 // letzte Stelle erhöhen, dabei evtl. Exponenten incrementieren
  46                 );
  47         }   }
  48 #else
  49       var uint32 semhi = TheDfloat(x)->dfloat_value.semhi;
  50       var uint32 mlo = TheDfloat(x)->dfloat_value.mlo;
  51       var uintL uexp = DF_uexp(semhi); // e + DF_exp_mid
  52       if (uexp==0) // 0.0 ?
  53         { return x; }
  54       if (uexp <= DF_exp_mid) // e<=0 ?
  55         { // Exponent auf 1, Mantisse auf .1000...000 setzen.
  56           return ((semhi & bit(31))==0 ? cl_DF_1 : cl_DF_minus1);
  57         }
  58         else
  59         { if (uexp > DF_exp_mid+DF_mant_len) // e > 52 ?
  60             { return x; }
  61             else
  62             if (uexp > DF_exp_mid+DF_mant_len+1-32) // e > 21 ?
  63               { var uint32 mask = // Bitmaske: Bits 52-e..0 gesetzt, alle anderen gelöscht
  64                   bit(DF_mant_len+1+DF_exp_mid-uexp)-1;
  65                 if ((mlo & mask)==0) // alle diese Bits =0 ?
  66                   { return x; }
  67                 mlo = (mlo | mask) // alle diese Bits setzen
  68                       + 1; // letzte Stelle erhöhen,
  69                 if (mlo==0) { semhi += 1; } // dabei evtl. Exponenten incrementieren
  70                 return allocate_dfloat(semhi,mlo);
  71               }
  72               else
  73               { var uint32 mask = // Bitmaske: Bits 20-e..0 gesetzt, alle anderen gelöscht
  74                   bit(DF_mant_len+1+DF_exp_mid-32-uexp)-1;
  75                 if ((mlo==0) && ((semhi & mask)==0)) // alle diese Bits und mlo =0 ?
  76                   { return x; }
  77                 return allocate_dfloat
  78                   ((semhi | mask) // alle diese Bits setzen
  79                    + 1, // letzte Stelle erhöhen, dabei evtl. Exponenten incrementieren
  80                    0
  81                   );
  82         }     }
  83 #endif
  84 }
  85
  86 }  // namespace cln