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

Subversion Repositories openrisc_me

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

Go to most recent revision | 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.