URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libm/] [common/] [s_lrint.c] - Blame information for rev 207

Details | Compare with Previous | View Log


 
/* @(#)s_lrint.c 5.1 93/09/24 */
/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunPro, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice
 * is preserved.
 * ====================================================
 */
/*
FUNCTION
<<lrint>>, <<lrintf>>, <<llrint>>, <<llrintf>>--round to integer
INDEX
        lrint
INDEX
        lrintf
INDEX
        llrint
INDEX
        llrintf
 
ANSI_SYNOPSIS
        #include <math.h>
        long int lrint(double <[x]>);
        long int lrintf(float <[x]>);
        long long int llrint(double <[x]>);
        long long int llrintf(float <[x]>);
 
DESCRIPTION
The <<lrint>> and <<llrint>> functions round their argument to the nearest
integer value, using the current rounding direction.  If the rounded value is
outside the range of the return type, the numeric result is unspecified.  A
range error may occur if the magnitude of <[x]> is too large.
The "inexact" floating-point exception is raised in implementations that
support it when the result differs in value from the argument (i.e., when
a fraction actually has been truncated).
 
RETURNS
<[x]> rounded to an integral value, using the current rounding direction.
 
SEEALSO
<<lround>>
 
PORTABILITY
ANSI C, POSIX
 
*/
 
/*
 * lrint(x)
 * Return x rounded to integral value according to the prevailing
 * rounding mode.
 * Method:
 *      Using floating addition.
 * Exception:
 *      Inexact flag raised if x not equal to lrint(x).
 */
 
#include "fdlibm.h"
 
#ifndef _DOUBLE_IS_32BITS
 
#ifdef __STDC__
static const double
#else
static double
#endif
 
/* Adding a double, x, to 2^52 will cause the result to be rounded based on
   the fractional part of x, according to the implementation's current rounding
   mode.  2^52 is the smallest double that can be represented using all 52 significant
   digits. */
TWO52[2]={
  4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */
 -4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */
};
 
#ifdef __STDC__
        long int lrint(double x)
#else
        long int lrint(x)
        double x;
#endif
{
  __int32_t i0,j0,sx;
  __uint32_t i1;
  double t;
  volatile double w;
  long int result;
 
  EXTRACT_WORDS(i0,i1,x);
 
  /* Extract sign bit. */
  sx = (i0>>31)&1;
 
  /* Extract exponent field. */
  j0 = ((i0 & 0x7ff00000) >> 20) - 1023;
 
  if(j0 < 20)
    {
      if(j0 < -1)
        return 0;
      else
        {
          w = TWO52[sx] + x;
          t = w - TWO52[sx];
          GET_HIGH_WORD(i0, t);
          /* Detect the all-zeros representation of plus and
             minus zero, which fails the calculation below. */
          if ((i0 & ~(1L << 31)) == 0)
              return 0;
          j0 = ((i0 & 0x7ff00000) >> 20) - 1023;
          i0 &= 0x000fffff;
          i0 |= 0x00100000;
          result = i0 >> (20 - j0);
        }
    }
  else if (j0 < (int)(8 * sizeof (long int)) - 1)
    {
      if (j0 >= 52)
        result = ((long int) ((i0 & 0x000fffff) | 0x0010000) << (j0 - 20)) |
                   (i1 << (j0 - 52));
      else
        {
          w = TWO52[sx] + x;
          t = w - TWO52[sx];
          EXTRACT_WORDS (i0, i1, t);
          j0 = ((i0 & 0x7ff00000) >> 20) - 1023;
          i0 &= 0x000fffff;
          i0 |= 0x00100000;
          result = ((long int) i0 << (j0 - 20)) | (i1 >> (52 - j0));
        }
    }
  else
    {
      return (long int) x;
    }
 
  return sx ? -result : result;
}
 
#endif /* _DOUBLE_IS_32BITS */

Line No.	Rev	Author	Line
1	207	jeremybenn
2			`/* @(#)s_lrint.c 5.1 93/09/24 */`
3			`/*`
4			`* ====================================================`
5			`* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.`
6			`*`
7			`* Developed at SunPro, a Sun Microsystems, Inc. business.`
8			`* Permission to use, copy, modify, and distribute this`
9			`* software is freely granted, provided that this notice`
10			`* is preserved.`
11			`* ====================================================`
12			`*/`
13			`/*`
14			`FUNCTION`
15			`<<lrint>>, <<lrintf>>, <<llrint>>, <<llrintf>>--round to integer`
16			`INDEX`
17			`lrint`
18			`INDEX`
19			`lrintf`
20			`INDEX`
21			`llrint`
22			`INDEX`
23			`llrintf`
24
25			`ANSI_SYNOPSIS`
26			`#include <math.h>`
27			`long int lrint(double <[x]>);`
28			`long int lrintf(float <[x]>);`
29			`long long int llrint(double <[x]>);`
30			`long long int llrintf(float <[x]>);`
31
32			`DESCRIPTION`
33			`The <<lrint>> and <<llrint>> functions round their argument to the nearest`
34			`integer value, using the current rounding direction. If the rounded value is`
35			`outside the range of the return type, the numeric result is unspecified. A`
36			`range error may occur if the magnitude of <[x]> is too large.`
37			`The "inexact" floating-point exception is raised in implementations that`
38			`support it when the result differs in value from the argument (i.e., when`
39			`a fraction actually has been truncated).`
40
41			`RETURNS`
42			`<[x]> rounded to an integral value, using the current rounding direction.`
43
44			`SEEALSO`
45			`<<lround>>`
46
47			`PORTABILITY`
48			`ANSI C, POSIX`
49
50			`*/`
51
52			`/*`
53			`* lrint(x)`
54			`* Return x rounded to integral value according to the prevailing`
55			`* rounding mode.`
56			`* Method:`
57			`* Using floating addition.`
58			`* Exception:`
59			`* Inexact flag raised if x not equal to lrint(x).`
60			`*/`
61
62			`#include "fdlibm.h"`
63
64			`#ifndef _DOUBLE_IS_32BITS`
65
66			`#ifdef __STDC__`
67			`static const double`
68			`#else`
69			`static double`
70			`#endif`
71
72			`/* Adding a double, x, to 2^52 will cause the result to be rounded based on`
73			`the fractional part of x, according to the implementation's current rounding`
74			`mode. 2^52 is the smallest double that can be represented using all 52 significant`
75			`digits. */`
76			`TWO52[2]={`
77			`4.50359962737049600000e+15, /* 0x43300000, 0x00000000 */`
78			`-4.50359962737049600000e+15, /* 0xC3300000, 0x00000000 */`
79			`};`
80
81			`#ifdef __STDC__`
82			`long int lrint(double x)`
83			`#else`
84			`long int lrint(x)`
85			`double x;`
86			`#endif`
87			`{`
88			`__int32_t i0,j0,sx;`
89			`__uint32_t i1;`
90			`double t;`
91			`volatile double w;`
92			`long int result;`
93
94			`EXTRACT_WORDS(i0,i1,x);`
95
96			`/* Extract sign bit. */`
97			`sx = (i0>>31)&1;`
98
99			`/* Extract exponent field. */`
100			`j0 = ((i0 & 0x7ff00000) >> 20) - 1023;`
101
102			`if(j0 < 20)`
103			`{`
104			`if(j0 < -1)`
105			`return 0;`
106			`else`
107			`{`
108			`w = TWO52[sx] + x;`
109			`t = w - TWO52[sx];`
110			`GET_HIGH_WORD(i0, t);`
111			`/* Detect the all-zeros representation of plus and`
112			`minus zero, which fails the calculation below. */`
113			`if ((i0 & ~(1L << 31)) == 0)`
114			`return 0;`
115			`j0 = ((i0 & 0x7ff00000) >> 20) - 1023;`
116			`i0 &= 0x000fffff;`
117			`i0 \|= 0x00100000;`
118			`result = i0 >> (20 - j0);`
119			`}`
120			`}`
121			`else if (j0 < (int)(8 * sizeof (long int)) - 1)`
122			`{`
123			`if (j0 >= 52)`
124			`result = ((long int) ((i0 & 0x000fffff) \| 0x0010000) << (j0 - 20)) \|`
125			`(i1 << (j0 - 52));`
126			`else`
127			`{`
128			`w = TWO52[sx] + x;`
129			`t = w - TWO52[sx];`
130			`EXTRACT_WORDS (i0, i1, t);`
131			`j0 = ((i0 & 0x7ff00000) >> 20) - 1023;`
132			`i0 &= 0x000fffff;`
133			`i0 \|= 0x00100000;`
134			`result = ((long int) i0 << (j0 - 20)) \| (i1 >> (52 - j0));`
135			`}`
136			`}`
137			`else`
138			`{`
139			`return (long int) x;`
140			`}`
141
142			`return sx ? -result : result;`
143			`}`
144
145			`#endif /* _DOUBLE_IS_32BITS */`

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libm/] [common/] [s_lrint.c] - Blame information for rev 207