src/float/ffloat/elem/cl_FF_fround.cc

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