Return to poly_2xm1.c CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / emulator

Annotation of coherent/b/kernel/emulator/poly_2xm1.c, revision 1.1.1.1

1.1       root        1: /*---------------------------------------------------------------------------+
                      2:  |  poly_2xm1.c                                                              |
                      3:  |                                                                           |
                      4:  | Function to compute 2^x-1 by a polynomial approximation.                  |
                      5:  |                                                                           |
                      6:  | Copyright (C) 1992    W. Metzenthen, 22 Parker St, Ormond, Vic 3163,      |
                      7:  |                       Australia.  E-mail [email protected]    |
                      8:  |                                                                           |
                      9:  |                                                                           |
                     10:  +---------------------------------------------------------------------------*/
                     11: 
                     12: #include "fpu_system.h"
                     13: #include "exception.h"
                     14: #include "reg_constant.h"
                     15: #include "fpu_emu.h"
                     16: 
                     17: 
                     18: 
                     19: #define        HIPOWER 13
                     20: static unsigned short  lterms[HIPOWER][4] =
                     21:        {
                     22:        { 0x79b5, 0xd1cf, 0x17f7, 0xb172 },
                     23:        { 0x1b56, 0x058b, 0x7bff, 0x3d7f },
                     24:        { 0x8bb0, 0x8250, 0x846b, 0x0e35 },
                     25:        { 0xbc65, 0xf747, 0x556d, 0x0276 },
                     26:        { 0x17cb, 0x9e39, 0x61ff, 0x0057 },
                     27:        { 0xe018, 0x9776, 0x1848, 0x000a },
                     28:        { 0x66f2, 0xff30, 0xffe5, 0x0000 },
                     29:        { 0x682f, 0xffb6, 0x162b, 0x0000 },
                     30:        { 0xb7ca, 0x2956, 0x01b5, 0x0000 },
                     31:        { 0xcd3e, 0x4817, 0x001e, 0x0000 },
                     32:        { 0xb7e2, 0xecbe, 0x0001, 0x0000 },
                     33:        { 0x0ed5, 0x1a27, 0x0000, 0x0000 },
                     34:        { 0x101d, 0x0222, 0x0000, 0x0000 },
                     35:        };
                     36: 
                     37: 
                     38: /*--- poly_2xm1() -----------------------------------------------------------+
                     39:  |                                                                           |
                     40:  +---------------------------------------------------------------------------*/
                     41: int    poly_2xm1(FPU_REG *arg, FPU_REG *result)
                     42: {
                     43:   short                exponent;
                     44:   long long     Xll;
                     45:   FPU_REG           accum;
                     46: 
                     47: 
                     48:   exponent = arg->exp - EXP_BIAS;
                     49: 
                     50:   if ( arg->tag == TW_Zero )
                     51:     {
                     52:       /* Return 0.0 */
                     53:       reg_move(&CONST_Z, result);
                     54:       return 0;
                     55:     }
                     56: 
                     57:   if ( exponent >= 0 ) /* Can't hack a number >= 1.0 */
                     58:     {
                     59:       arith_invalid(result);
                     60:       return 1;
                     61:     }
                     62: 
                     63:   if ( arg->sign != SIGN_POS ) /* Can't hack a number < 0.0 */
                     64:     {
                     65:       arith_invalid(result);
                     66:       return 1;
                     67:     }
                     68:   
                     69:   if ( exponent < -64 )
                     70:     {
                     71:       reg_move(&CONST_LN2, result);
                     72:       return 0;
                     73:     }
                     74: 
                     75:   *(unsigned *)&Xll = arg->sigl;
                     76:   *(((unsigned *)&Xll)+1) = arg->sigh;
                     77:   if ( exponent < -1 )
                     78:     {
                     79:       /* shift the argument right by the required places */
                     80:       if ( shrx(&Xll, -1-exponent) >= 0x80000000U )
                     81:        Xll++;  /* round up */
                     82:     }
                     83: 
                     84:   *(short *)&(accum.sign) = 0; /* will be a valid positive nr with expon = 0 */
                     85:   accum.exp = 0;
                     86: 
                     87:   /* Do the basic fixed point polynomial evaluation */
                     88:   polynomial((unsigned *)&accum.sigl, (unsigned *)&Xll, lterms, HIPOWER-1);
                     89: 
                     90:   /* Convert to 64 bit signed-compatible */
                     91:   accum.exp += EXP_BIAS - 1;
                     92: 
                     93:   reg_move(&accum, result);
                     94: 
                     95:   normalize(result);
                     96: 
                     97:   return 0;
                     98: 
                     99: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.