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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.17.0/] [newlib/] [libm/] [common/] [s_modf.c] - Blame information for rev 310

Go to most recent revision | Details | Compare with Previous | View Log


 
/* @(#)s_modf.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
       <<modf>>, <<modff>>---split fractional and integer parts
 
INDEX
        modf
INDEX
        modff
 
ANSI_SYNOPSIS
        #include <math.h>
        double modf(double <[val]>, double *<[ipart]>);
        float modff(float <[val]>, float *<[ipart]>);
 
TRAD_SYNOPSIS
        #include <math.h>
        double modf(<[val]>, <[ipart]>)
        double <[val]>;
        double *<[ipart]>;
 
        float modff(<[val]>, <[ipart]>)
        float <[val]>;
        float *<[ipart]>;
 
DESCRIPTION
        <<modf>> splits the double <[val]> apart into an integer part
        and a fractional part, returning the fractional part and
        storing the integer part in <<*<[ipart]>>>.  No rounding
        whatsoever is done; the sum of the integer and fractional
        parts is guaranteed to be exactly  equal to <[val]>.   That
        is, if <[realpart]> = modf(<[val]>, &<[intpart]>); then
        `<<<[realpart]>+<[intpart]>>>' is the same as <[val]>.
        <<modff>> is identical, save that it takes and returns
        <<float>> rather than <<double>> values.
 
RETURNS
        The fractional part is returned.  Each result has the same
        sign as the supplied argument <[val]>.
 
PORTABILITY
        <<modf>> is ANSI C. <<modff>> is an extension.
 
QUICKREF
        modf  ansi pure
        modff - pure
 
*/
 
/*
 * modf(double x, double *iptr)
 * return fraction part of x, and return x's integral part in *iptr.
 * Method:
 *      Bit twiddling.
 *
 * Exception:
 *      No exception.
 */
 
#include "fdlibm.h"
 
#ifndef _DOUBLE_IS_32BITS
 
#ifdef __STDC__
static const double one = 1.0;
#else
static double one = 1.0;
#endif
 
#ifdef __STDC__
        double modf(double x, double *iptr)
#else
        double modf(x, iptr)
        double x,*iptr;
#endif
{
        __int32_t i0,i1,j0;
        __uint32_t i;
        EXTRACT_WORDS(i0,i1,x);
        j0 = ((i0>>20)&0x7ff)-0x3ff;    /* exponent of x */
        if(j0<20) {                     /* integer part in high x */
            if(j0<0) {                   /* |x|<1 */
                INSERT_WORDS(*iptr,i0&0x80000000,0);     /* *iptr = +-0 */
                return x;
            } else {
                i = (0x000fffff)>>j0;
                if(((i0&i)|i1)==0) {             /* x is integral */
                    __uint32_t high;
                    *iptr = x;
                    GET_HIGH_WORD(high,x);
                    INSERT_WORDS(x,high&0x80000000,0);   /* return +-0 */
                    return x;
                } else {
                    INSERT_WORDS(*iptr,i0&(~i),0);
                    return x - *iptr;
                }
            }
        } else if (j0>51) {             /* no fraction part */
            __uint32_t high;
            *iptr = x*one;
            GET_HIGH_WORD(high,x);
            INSERT_WORDS(x,high&0x80000000,0);   /* return +-0 */
            return x;
        } else {                        /* fraction part in low x */
            i = ((__uint32_t)(0xffffffff))>>(j0-20);
            if((i1&i)==0) {              /* x is integral */
                __uint32_t high;
                *iptr = x;
                GET_HIGH_WORD(high,x);
                INSERT_WORDS(x,high&0x80000000,0);       /* return +-0 */
                return x;
            } else {
                INSERT_WORDS(*iptr,i0,i1&(~i));
                return x - *iptr;
            }
        }
}
 
#endif /* _DOUBLE_IS_32BITS */

Line No.	Rev	Author	Line
1	148	jeremybenn
2			`/* @(#)s_modf.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			`/*`
15			`FUNCTION`
16			`<<modf>>, <<modff>>---split fractional and integer parts`
17
18			`INDEX`
19			`modf`
20			`INDEX`
21			`modff`
22
23			`ANSI_SYNOPSIS`
24			`#include <math.h>`
25			`double modf(double <[val]>, double *<[ipart]>);`
26			`float modff(float <[val]>, float *<[ipart]>);`
27
28			`TRAD_SYNOPSIS`
29			`#include <math.h>`
30			`double modf(<[val]>, <[ipart]>)`
31			`double <[val]>;`
32			`double *<[ipart]>;`
33
34			`float modff(<[val]>, <[ipart]>)`
35			`float <[val]>;`
36			`float *<[ipart]>;`
37
38			`DESCRIPTION`
39			`<<modf>> splits the double <[val]> apart into an integer part`
40			`and a fractional part, returning the fractional part and`
41			`storing the integer part in <<*<[ipart]>>>. No rounding`
42			`whatsoever is done; the sum of the integer and fractional`
43			`parts is guaranteed to be exactly equal to <[val]>. That`
44			`is, if <[realpart]> = modf(<[val]>, &<[intpart]>); then`
45			`<<<[realpart]>+<[intpart]>>>' is the same as <[val]>.
46			`<<modff>> is identical, save that it takes and returns`
47			`<<float>> rather than <<double>> values.`
48
49			`RETURNS`
50			`The fractional part is returned. Each result has the same`
51			`sign as the supplied argument <[val]>.`
52
53			`PORTABILITY`
54			`<<modf>> is ANSI C. <<modff>> is an extension.`
55
56			`QUICKREF`
57			`modf ansi pure`
58			`modff - pure`
59
60			`*/`
61
62			`/*`
63			`* modf(double x, double *iptr)`
64			`* return fraction part of x, and return x's integral part in *iptr.`
65			`* Method:`
66			`* Bit twiddling.`
67			`*`
68			`* Exception:`
69			`* No exception.`
70			`*/`
71
72			`#include "fdlibm.h"`
73
74			`#ifndef _DOUBLE_IS_32BITS`
75
76			`#ifdef __STDC__`
77			`static const double one = 1.0;`
78			`#else`
79			`static double one = 1.0;`
80			`#endif`
81
82			`#ifdef __STDC__`
83			`double modf(double x, double *iptr)`
84			`#else`
85			`double modf(x, iptr)`
86			`double x,*iptr;`
87			`#endif`
88			`{`
89			`__int32_t i0,i1,j0;`
90			`__uint32_t i;`
91			`EXTRACT_WORDS(i0,i1,x);`
92			`j0 = ((i0>>20)&0x7ff)-0x3ff; /* exponent of x */`
93			`if(j0<20) { /* integer part in high x */`
94			`if(j0<0) { /* \|x\|<1 */`
95			`INSERT_WORDS(iptr,i0&0x80000000,0); / iptr = +-0 /`
96			`return x;`
97			`} else {`
98			`i = (0x000fffff)>>j0;`
99			`if(((i0&i)\|i1)==0) { /* x is integral */`
100			`__uint32_t high;`
101			`*iptr = x;`
102			`GET_HIGH_WORD(high,x);`
103			`INSERT_WORDS(x,high&0x80000000,0); /* return +-0 */`
104			`return x;`
105			`} else {`
106			`INSERT_WORDS(*iptr,i0&(~i),0);`
107			`return x - *iptr;`
108			`}`
109			`}`
110			`} else if (j0>51) { /* no fraction part */`
111			`__uint32_t high;`
112			`iptr = xone;`
113			`GET_HIGH_WORD(high,x);`
114			`INSERT_WORDS(x,high&0x80000000,0); /* return +-0 */`
115			`return x;`
116			`} else { /* fraction part in low x */`
117			`i = ((__uint32_t)(0xffffffff))>>(j0-20);`
118			`if((i1&i)==0) { /* x is integral */`
119			`__uint32_t high;`
120			`*iptr = x;`
121			`GET_HIGH_WORD(high,x);`
122			`INSERT_WORDS(x,high&0x80000000,0); /* return +-0 */`
123			`return x;`
124			`} else {`
125			`INSERT_WORDS(*iptr,i0,i1&(~i));`
126			`return x - *iptr;`
127			`}`
128			`}`
129			`}`
130
131			`#endif /* _DOUBLE_IS_32BITS */`

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.17.0/] [newlib/] [libm/] [common/] [s_modf.c] - Blame information for rev 310