src/float/lfloat/elem/cl_LF_fround.cc

   1 // fround().
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 // Specification.
   7 #include "cl_lfloat.h"
   8
   9
  10 // Implementation.
  11
  12 #include "cl_LF.h"
  13 #include "cl_LF_impl.h"
  14 #include "cl_DS.h"
  15
  16 const cl_LF fround (const cl_LF& x)
  17 {
  18 // Methode:
  19 // x = 0.0 oder e<0 -> Ergebnis 0.0
  20 // 0<=e<16n -> letzte (16n-e) Bits der Mantisse wegrunden,
  21 //             Exponent und Vorzeichen beibehalten.
  22 // e>=16n -> Ergebnis x
  23 #if 0
  24       var cl_signean sign;
  25       var sintL exp;
  26       var const uintD* mantMSDptr;
  27       var uintC mantlen;
  28       LF_decode(x, { return x; }, sign=,exp=,mantMSDptr=,mantlen=,);
  29       if (exp<0) { return encode_LF0(mantlen); } // e<0 -> Ergebnis 0.0
  30       if ((uintL)exp >= intDsize*(uintL)mantlen) // e>=16n -> x als Ergebnis
  31         { return x; }
  32         else
  33         // 0 <= e < 16n
  34         { // alle hinteren 16n-e Bits wegrunden:
  35           var uintC count = floor((uintL)exp,intDsize); // zu kopierende Digits, < mantlen
  36           var uintC bitcount = ((uintL)exp) % intDsize; // zu kopierende Bits danach, >=0, <intDsize
  37           var uintD mask = minus_bit(intDsize-bitcount-1); // Maske mit bitcount+1 Bits
  38           var const uintD* mantptr = mantMSDptr mspop count;
  39           if ((mspref(mantptr,0) & -mask) ==0) goto ab; // Bit 16n-e-1 =0 -> abrunden
  40           if (!((mspref(mantptr,0) & ~mask) ==0)) goto auf; // Bit 16n-e-1 =1 und Bits 16n-e-2..0 >0 -> aufrunden
  41           if (test_loop_msp(mantptr mspop 1,mantlen-count-1)) goto auf;
  42           // round-to-even, je nach Bit 16n-e :
  43           if (bitcount>0)
  44             { if ((mspref(mantptr,0) & (-2*mask)) ==0) goto ab; else goto auf; }
  45             elif (count>0)
  46               { if ((lspref(mantptr,0) & bit(0)) ==0) goto ab; else goto auf; }
  47               else
  48               // bitcount=0, count=0, also exp=0: Abrunden von +-0.5 zu 0.0
  49               { return encode_LF0(mantlen); }
  50           ab: // abrunden
  51           { CL_ALLOCA_STACK;
  52             var uintD* MSDptr;
  53             num_stack_alloc(mantlen, MSDptr=,);
  54            {var uintD* ptr =
  55               copy_loop_msp(mantMSDptr,MSDptr,count); // count ganze Digits kopieren
  56             msprefnext(ptr) = mspref(mantptr,0) & mask; // dann bitcount Bits kopieren
  57             clear_loop_msp(ptr,mantlen-count-1); // Rest mit Nullen füllen
  58             return encode_LF(sign,exp,MSDptr,mantlen);
  59           }}
  60           auf: // aufrunden
  61           { CL_ALLOCA_STACK;
  62             var uintD* MSDptr;
  63             num_stack_alloc(mantlen, MSDptr=,);
  64            {var uintD* ptr =
  65               copy_loop_msp(mantMSDptr,MSDptr,count); // count ganze Digits kopieren
  66             if ((mspref(ptr,0) = ((mspref(mantptr,0) & mask) - mask)) == 0) // dann bitcount Bits kopieren und incrementieren
  67               { if (!( inc_loop_lsp(ptr,count) ==0)) // evtl. weiterincrementieren
  68                   { mspref(MSDptr,0) = bit(intDsize-1); exp = exp+1; } // evtl. Exponenten erhöhen
  69               }
  70             clear_loop_msp(ptr mspop 1,mantlen-count-1); // Rest mit Nullen füllen
  71             return encode_LF(sign,exp,MSDptr,mantlen);
  72           }}
  73         }
  74 #else
  75       var uintC len = TheLfloat(x)->len;
  76       var uintL uexp = TheLfloat(x)->expo;
  77       if (uexp < LF_exp_mid)
  78         { if (uexp == 0) { return x; } // x=0.0 -> Ergebnis 0.0
  79           return encode_LF0(len); // e<0 -> Ergebnis 0.0
  80         }
  81       var uintL exp = uexp - LF_exp_mid;
  82       if (exp >= intDsize*(uintL)len) // e>=16n -> x als Ergebnis
  83         { return x; }
  84       // 0 <= e < 16n
  85       // alle hinteren 16n-e Bits wegrunden:
  86       var uintC count = floor(exp,intDsize); // zu kopierende Digits, < mantlen
  87       var uintC bitcount = exp % intDsize; // zu kopierende Bits danach, >=0, <intDsize
  88       var uintD mask = minus_bit(intDsize-bitcount-1); // Maske mit bitcount+1 Bits
  89       {var const uintD* mantptr = LF_MSDptr(x) mspop count;
  90        #if !(defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 7))
  91        if ((mspref(mantptr,0) & -mask) ==0) goto ab; // Bit 16n-e-1 =0 -> abrunden
  92        #else
  93        // Work around gcc-2.7.x bug on i386/ELF
  94        if ((mspref(mantptr,0) & ((~mask)+1)) ==0) goto ab; // Bit 16n-e-1 =0 -> abrunden
  95        #endif
  96        if (!((mspref(mantptr,0) & ~mask) ==0)) goto auf; // Bit 16n-e-1 =1 und Bits 16n-e-2..0 >0 -> aufrunden
  97        if (test_loop_msp(mantptr mspop 1,len-count-1)) goto auf;
  98        // round-to-even, je nach Bit 16n-e :
  99        if (bitcount>0)
 100          { if ((mspref(mantptr,0) & (-2*mask)) ==0) goto ab; else goto auf; }
 101          elif (count>0)
 102            { if ((lspref(mantptr,0) & bit(0)) ==0) goto ab; else goto auf; }
 103            else
 104            // bitcount=0, count=0, also exp=0: Abrunden von +-0.5 zu 0.0
 105            { return encode_LF0(len); }
 106       }
 107       ab: // abrunden
 108         {var Lfloat y = allocate_lfloat(len,uexp,TheLfloat(x)->sign); // neues Long-Float
 109          // y_mant := NUDS mit e Bits aus x_mant und 16n-e Nullbits:
 110          {var const uintD* x_mantMSDptr = LF_MSDptr(x);
 111           var uintD* ptr =
 112             copy_loop_msp(x_mantMSDptr,arrayMSDptr(TheLfloat(y)->data,len),count); // count ganze Digits kopieren
 113           msprefnext(ptr) = mspref(x_mantMSDptr,count) & mask; // dann bitcount Bits kopieren
 114           clear_loop_msp(ptr,len-count-1); // Rest mit Nullen füllen
 115          }
 116          return y;
 117         }
 118       auf: // aufrunden
 119         {var Lfloat y = allocate_lfloat(len,uexp,TheLfloat(x)->sign); // neues Long-Float
 120          // y_mant := NUDS mit e Bits aus x_mant mit Increment und 16n-e Nullbits:
 121          {var const uintD* x_mantMSDptr = LF_MSDptr(x);
 122           var uintD* y_mantMSDptr = arrayMSDptr(TheLfloat(y)->data,len);
 123           var uintD* ptr =
 124             copy_loop_msp(x_mantMSDptr,y_mantMSDptr,count); // count ganze Digits kopieren
 125           if ((mspref(ptr,0) = ((mspref(x_mantMSDptr,count) & mask) - mask)) == 0) // dann bitcount Bits kopieren und incrementieren
 126             { if (!( inc_loop_lsp(ptr,count) ==0)) // evtl. weiterincrementieren
 127                 { mspref(y_mantMSDptr,0) = bit(intDsize-1); (TheLfloat(y)->expo)++; } // evtl. Exponenten erhöhen
 128             }
 129           clear_loop_msp(ptr mspop 1,len-count-1); // Rest mit Nullen füllen
 130          }
 131          return y;
 132         }
 133 #endif
 134 }