src/float/ffloat/elem/cl_FF_fround.cc

   1 // fround().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cln/ffloat.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cl_FF.h"
  13
  14 namespace cln {
  15
  16 const cl_FF fround (const cl_FF& x)
  17 {
  18 // Methode:
  19 // x = 0.0 oder e<0 -> Ergebnis 0.0
  20 // 0<=e<=23 -> letzte (24-e) Bits der Mantisse wegrunden,
  21 //             Exponent und Vorzeichen beibehalten.
  22 // e>23 -> Ergebnis x
  23       var ffloat x_ = cl_ffloat_value(x);
  24       var uintL uexp = FF_uexp(x_); // e + FF_exp_mid
  25       if (uexp < FF_exp_mid) // x = 0.0 oder e<0 ?
  26         { return cl_FF_0; }
  27         else
  28         { if (uexp > FF_exp_mid+FF_mant_len) // e > 23 ?
  29             { return x; }
  30             else
  31             if (uexp > FF_exp_mid+1) // e>1 ?
  32               { var uint32 bitmask = // Bitmaske: Bit 23-e gesetzt, alle anderen gelöscht
  33                   bit(FF_mant_len+FF_exp_mid-uexp);
  34                 var uint32 mask = // Bitmaske: Bits 22-e..0 gesetzt, alle anderen gelöscht
  35                   bitmask-1;
  36                 if ( ((x_ & bitmask) ==0) // Bit 23-e =0 -> abrunden
  37                      || ( ((x_ & mask) ==0) // Bit 23-e =1 und Bits 22-e..0 >0 -> aufrunden
  38                           // round-to-even, je nach Bit 24-e :
  39                           && ((x_ & (bitmask<<1)) ==0)
  40                    )    )
  41                   // abrunden
  42                   { mask |= bitmask; // Bitmaske: Bits 23-e..0 gesetzt, alle anderen gelöscht
  43                     return allocate_ffloat( x_ & ~mask );
  44                   }
  45                   else
  46                   // aufrunden
  47                   { return allocate_ffloat
  48                       ((x_ | mask) // alle diese Bits 22-e..0 setzen (Bit 23-e schon gesetzt)
  49                        + 1 // letzte Stelle erhöhen, dabei evtl. Exponenten incrementieren
  50                       );
  51                   }
  52               }
  53             elif (uexp == FF_exp_mid+1) // e=1 ?
  54               // Wie bei 1 < e <= 23, nur daß Bit 24-e stets gesetzt ist.
  55               { if ((x_ & bit(FF_mant_len-1)) ==0) // Bit 23-e =0 -> abrunden
  56                   // abrunden
  57                   { return allocate_ffloat( x_ & ~(bit(FF_mant_len)-1) ); }
  58                   else
  59                   // aufrunden
  60                   { return allocate_ffloat
  61                       ((x_ | (bit(FF_mant_len)-1)) // alle diese Bits 23-e..0 setzen
  62                        + 1 // letzte Stelle erhöhen, dabei evtl. Exponenten incrementieren
  63                       );
  64                   }
  65               }
  66             else // e=0 ?
  67               // Wie bei 1 < e <= 23, nur daß Bit 23-e stets gesetzt
  68               // und Bit 24-e stets gelöscht ist.
  69               { if ((x_ & (bit(FF_mant_len)-1)) ==0)
  70                   // abrunden von +-0.5 zu 0.0
  71                   { return cl_FF_0; }
  72                   else
  73                   // aufrunden
  74                   { return allocate_ffloat
  75                       ((x_ | (bit(FF_mant_len)-1)) // alle Bits 22-e..0 setzen
  76                        + 1 // letzte Stelle erhöhen, dabei Exponenten incrementieren
  77                       );
  78               }   }
  79         }
  80 }
  81
  82 }  // namespace cln