OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [newlib-1.17.0/] [newlib/] [libm/] [math/] [w_pow.c] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 148 jeremybenn
 
2
 
3
/* @(#)w_pow.c 5.2 93/10/01 */
4
/*
5
 * ====================================================
6
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
7
 *
8
 * Developed at SunPro, a Sun Microsystems, Inc. business.
9
 * Permission to use, copy, modify, and distribute this
10
 * software is freely granted, provided that this notice
11
 * is preserved.
12
 * ====================================================
13
 */
14
 
15
/*
16
FUNCTION
17
        <<pow>>, <<powf>>---x to the power y
18
INDEX
19
        pow
20
INDEX
21
        powf
22
 
23
 
24
ANSI_SYNOPSIS
25
        #include <math.h>
26
        double pow(double <[x]>, double <[y]>);
27
        float powf(float <[x]>, float <[y]>);
28
 
29
TRAD_SYNOPSIS
30
        #include <math.h>
31
        double pow(<[x]>, <[y]>);
32
        double <[x]>, <[y]>;
33
 
34
        float powf(<[x]>, <[y]>);
35
        float <[x]>, <[y]>;
36
 
37
DESCRIPTION
38
        <<pow>> and <<powf>> calculate <[x]> raised to the exponent <[y]>.
39
        @tex
40
        (That is, $x^y$.)
41
        @end tex
42
 
43
RETURNS
44
        On success, <<pow>> and <<powf>> return the value calculated.
45
 
46
        When the argument values would produce overflow, <<pow>>
47
        returns <<HUGE_VAL>> and set <<errno>> to <<ERANGE>>.  If the
48
        argument <[x]> passed to <<pow>> or <<powf>> is a negative
49
        noninteger, and <[y]> is also not an integer, then <<errno>>
50
        is set to <<EDOM>>.  If <[x]> and <[y]> are both 0, then
51
        <<pow>> and <<powf>> return <<1>>.
52
 
53
        You can modify error handling for these functions using <<matherr>>.
54
 
55
PORTABILITY
56
        <<pow>> is ANSI C. <<powf>> is an extension.  */
57
 
58
/*
59
 * wrapper pow(x,y) return x**y
60
 */
61
 
62
#include "fdlibm.h"
63
#include <errno.h>
64
 
65
#ifndef _DOUBLE_IS_32BITS
66
 
67
#ifdef __STDC__
68
        double pow(double x, double y)  /* wrapper pow */
69
#else
70
        double pow(x,y)                 /* wrapper pow */
71
        double x,y;
72
#endif
73
{
74
#ifdef _IEEE_LIBM
75
        return  __ieee754_pow(x,y);
76
#else
77
        double z;
78
#ifndef HUGE_VAL 
79
#define HUGE_VAL inf
80
        double inf = 0.0;
81
 
82
        SET_HIGH_WORD(inf,0x7ff00000);  /* set inf to infinite */
83
#endif
84
        struct exception exc;
85
        z=__ieee754_pow(x,y);
86
        if(_LIB_VERSION == _IEEE_|| isnan(y)) return z;
87
        if(isnan(x)) {
88
            if(y==0.0) {
89
                /* pow(NaN,0.0) */
90
                /* error only if _LIB_VERSION == _SVID_ & _XOPEN_ */
91
                exc.type = DOMAIN;
92
                exc.name = "pow";
93
                exc.err = 0;
94
                exc.arg1 = x;
95
                exc.arg2 = y;
96
                exc.retval = 1.0;
97
                if (_LIB_VERSION == _IEEE_ ||
98
                    _LIB_VERSION == _POSIX_) exc.retval = 1.0;
99
                else if (!matherr(&exc)) {
100
                        errno = EDOM;
101
                }
102
                if (exc.err != 0)
103
                   errno = exc.err;
104
                return exc.retval;
105
            } else
106
                return z;
107
        }
108
        if(x==0.0){
109
            if(y==0.0) {
110
                /* pow(0.0,0.0) */
111
                /* error only if _LIB_VERSION == _SVID_ */
112
                exc.type = DOMAIN;
113
                exc.name = "pow";
114
                exc.err = 0;
115
                exc.arg1 = x;
116
                exc.arg2 = y;
117
                exc.retval = 0.0;
118
                if (_LIB_VERSION != _SVID_) exc.retval = 1.0;
119
                else if (!matherr(&exc)) {
120
                        errno = EDOM;
121
                }
122
                if (exc.err != 0)
123
                   errno = exc.err;
124
                return exc.retval;
125
            }
126
            if(finite(y)&&y<0.0) {
127
                /* 0**neg */
128
                exc.type = DOMAIN;
129
                exc.name = "pow";
130
                exc.err = 0;
131
                exc.arg1 = x;
132
                exc.arg2 = y;
133
                if (_LIB_VERSION == _SVID_)
134
                  exc.retval = 0.0;
135
                else
136
                  exc.retval = -HUGE_VAL;
137
                if (_LIB_VERSION == _POSIX_)
138
                  errno = EDOM;
139
                else if (!matherr(&exc)) {
140
                  errno = EDOM;
141
                }
142
                if (exc.err != 0)
143
                   errno = exc.err;
144
                return exc.retval;
145
            }
146
            return z;
147
        }
148
        if(!finite(z)) {
149
            if(finite(x)&&finite(y)) {
150
                if(isnan(z)) {
151
                    /* neg**non-integral */
152
                    exc.type = DOMAIN;
153
                    exc.name = "pow";
154
                    exc.err = 0;
155
                    exc.arg1 = x;
156
                    exc.arg2 = y;
157
                    if (_LIB_VERSION == _SVID_)
158
                        exc.retval = 0.0;
159
                    else
160
                        exc.retval = 0.0/0.0;   /* X/Open allow NaN */
161
                    if (_LIB_VERSION == _POSIX_)
162
                        errno = EDOM;
163
                    else if (!matherr(&exc)) {
164
                        errno = EDOM;
165
                    }
166
                    if (exc.err != 0)
167
                        errno = exc.err;
168
                    return exc.retval;
169
                } else {
170
                    /* pow(x,y) overflow */
171
                    exc.type = OVERFLOW;
172
                    exc.name = "pow";
173
                    exc.err = 0;
174
                    exc.arg1 = x;
175
                    exc.arg2 = y;
176
                    if (_LIB_VERSION == _SVID_) {
177
                       exc.retval = HUGE;
178
                       y *= 0.5;
179
                       if(x<0.0&&rint(y)!=y) exc.retval = -HUGE;
180
                    } else {
181
                       exc.retval = HUGE_VAL;
182
                       y *= 0.5;
183
                       if(x<0.0&&rint(y)!=y) exc.retval = -HUGE_VAL;
184
                    }
185
                    if (_LIB_VERSION == _POSIX_)
186
                        errno = ERANGE;
187
                    else if (!matherr(&exc)) {
188
                        errno = ERANGE;
189
                    }
190
                    if (exc.err != 0)
191
                        errno = exc.err;
192
                    return exc.retval;
193
                }
194
            }
195
        }
196
        if(z==0.0&&finite(x)&&finite(y)) {
197
            /* pow(x,y) underflow */
198
            exc.type = UNDERFLOW;
199
            exc.name = "pow";
200
            exc.err = 0;
201
            exc.arg1 = x;
202
            exc.arg2 = y;
203
            exc.retval =  0.0;
204
            if (_LIB_VERSION == _POSIX_)
205
                errno = ERANGE;
206
            else if (!matherr(&exc)) {
207
                errno = ERANGE;
208
            }
209
            if (exc.err != 0)
210
                errno = exc.err;
211
            return exc.retval;
212
        }
213
        return z;
214
#endif
215
}
216
 
217
#endif /* defined(_DOUBLE_IS_32BITS) */
218
 
219
 
220
 
221
 
222
 
223
 
224
 
225
 
226
 
227
 
228
 
229
 
230
 
231
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.