diff options
-rw-r--r-- | regress/lib/libc/cephes/Makefile | 7 | ||||
-rw-r--r-- | regress/lib/libc/cephes/drand.c | 174 | ||||
-rw-r--r-- | regress/lib/libc/cephes/econst.c | 114 | ||||
-rw-r--r-- | regress/lib/libc/cephes/eexp.c | 86 | ||||
-rw-r--r-- | regress/lib/libc/cephes/ehead.h | 59 | ||||
-rw-r--r-- | regress/lib/libc/cephes/elog.c | 110 | ||||
-rw-r--r-- | regress/lib/libc/cephes/epow.c | 187 | ||||
-rw-r--r-- | regress/lib/libc/cephes/etanh.c | 70 | ||||
-rw-r--r-- | regress/lib/libc/cephes/etodec.c | 199 | ||||
-rw-r--r-- | regress/lib/libc/cephes/ieee.c | 4153 | ||||
-rw-r--r-- | regress/lib/libc/cephes/ieetst.c | 875 | ||||
-rw-r--r-- | regress/lib/libc/cephes/mconf.h | 187 | ||||
-rw-r--r-- | regress/lib/libc/cephes/mtherr.c | 114 |
13 files changed, 6335 insertions, 0 deletions
diff --git a/regress/lib/libc/cephes/Makefile b/regress/lib/libc/cephes/Makefile new file mode 100644 index 00000000000..75cc85f4a88 --- /dev/null +++ b/regress/lib/libc/cephes/Makefile @@ -0,0 +1,7 @@ +# $OpenBSD: Makefile,v 1.1 2011/07/02 18:11:01 martynas Exp $ + +PROG = ieetst +SRCS = drand.c econst.c eexp.c elog.c epow.c etanh.c etodec.c ieee.c \ + ieetst.c mtherr.c + +.include <bsd.regress.mk> diff --git a/regress/lib/libc/cephes/drand.c b/regress/lib/libc/cephes/drand.c new file mode 100644 index 00000000000..7f7000b4e8a --- /dev/null +++ b/regress/lib/libc/cephes/drand.c @@ -0,0 +1,174 @@ +/* $OpenBSD: drand.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* drand.c + * + * Pseudorandom number generator + * + * + * + * SYNOPSIS: + * + * double y, drand(); + * + * drand( &y ); + * + * + * + * DESCRIPTION: + * + * Yields a random number 1.0 <= y < 2.0. + * + * The three-generator congruential algorithm by Brian + * Wichmann and David Hill (BYTE magazine, March, 1987, + * pp 127-8) is used. The period, given by them, is + * 6953607871644. + * + * Versions invoked by the different arithmetic compile + * time options DEC, IBMPC, and MIEEE, produce + * approximately the same sequences, differing only in the + * least significant bits of the numbers. The UNK option + * implements the algorithm as recommended in the BYTE + * article. It may be used on all computers. However, + * the low order bits of a double precision number may + * not be adequately random, and may vary due to arithmetic + * implementation details on different computers. + * + * The other compile options generate an additional random + * integer that overwrites the low order bits of the double + * precision number. This reduces the period by a factor of + * two but tends to overcome the problems mentioned. + * + */ + +#include "mconf.h" + + +/* Three-generator random number algorithm + * of Brian Wichmann and David Hill + * BYTE magazine, March, 1987 pp 127-8 + * + * The period, given by them, is (p-1)(q-1)(r-1)/4 = 6.95e12. + */ + +static int sx = 1; +static int sy = 10000; +static int sz = 3000; + +static union { + double d; + unsigned short s[4]; +} unkans; + +/* This function implements the three + * congruential generators. + */ + +static int ranwh() +{ +int r, s; + +/* sx = sx * 171 mod 30269 */ +r = sx/177; +s = sx - 177 * r; +sx = 171 * s - 2 * r; +if( sx < 0 ) + sx += 30269; + + +/* sy = sy * 172 mod 30307 */ +r = sy/176; +s = sy - 176 * r; +sy = 172 * s - 35 * r; +if( sy < 0 ) + sy += 30307; + +/* sz = 170 * sz mod 30323 */ +r = sz/178; +s = sz - 178 * r; +sz = 170 * s - 63 * r; +if( sz < 0 ) + sz += 30323; +/* The results are in static sx, sy, sz. */ +return 0; +} + +/* drand.c + * + * Random double precision floating point number between 1 and 2. + * + * C callable: + * drand( &x ); + */ + +int drand( a ) +double *a; +{ +unsigned short r; +#ifdef DEC +unsigned short s, t; +#endif + +/* This algorithm of Wichmann and Hill computes a floating point + * result: + */ +ranwh(); +unkans.d = sx/30269.0 + sy/30307.0 + sz/30323.0; +r = unkans.d; +unkans.d -= r; +unkans.d += 1.0; + +/* if UNK option, do nothing further. + * Otherwise, make a random 16 bit integer + * to overwrite the least significant word + * of unkans. + */ +#ifdef UNK +/* do nothing */ +#else +ranwh(); +r = sx * sy + sz; +#endif + +#ifdef DEC +/* To make the numbers as similar as possible + * in all arithmetics, the random integer has + * to be inserted 3 bits higher up in a DEC number. + * An alternative would be put it 3 bits lower down + * in all the other number types. + */ +s = unkans.s[2]; +t = s & 07; /* save these bits to put in at the bottom */ +s &= 0177770; +s |= (r >> 13) & 07; +unkans.s[2] = s; +t |= r << 3; +unkans.s[3] = t; +#endif + +#ifdef IBMPC +unkans.s[0] = r; +#endif + +#ifdef MIEEE +unkans.s[3] = r; +#endif + +*a = unkans.d; +return 0; +} diff --git a/regress/lib/libc/cephes/econst.c b/regress/lib/libc/cephes/econst.c new file mode 100644 index 00000000000..4232059e4ca --- /dev/null +++ b/regress/lib/libc/cephes/econst.c @@ -0,0 +1,114 @@ +/* $OpenBSD: econst.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* econst.c */ +/* e type constants used by high precision check routines */ + +#include "ehead.h" + + +#if NE == 10 +/* 0.0 */ +unsigned short ezero[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,}; + +/* 5.0E-1 */ +unsigned short ehalf[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3ffe,}; + +/* 1.0E0 */ +unsigned short eone[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,}; + +/* 2.0E0 */ +unsigned short etwo[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x4000,}; + +/* 3.2E1 */ +unsigned short e32[NE] = + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x4004,}; + +/* 6.93147180559945309417232121458176568075500134360255E-1 */ +unsigned short elog2[NE] = + {0x40f3, 0xf6af, 0x03f2, 0xb398, + 0xc9e3, 0x79ab, 0150717, 0013767, 0130562, 0x3ffe,}; + +/* 1.41421356237309504880168872420969807856967187537695E0 */ +unsigned short esqrt2[NE] = + {0x1d6f, 0xbe9f, 0x754a, 0x89b3, + 0x597d, 0x6484, 0174736, 0171463, 0132404, 0x3fff,}; + +/* 3.14159265358979323846264338327950288419716939937511E0 */ +unsigned short epi[NE] = + {0x2902, 0x1cd1, 0x80dc, 0x628b, + 0xc4c6, 0xc234, 0020550, 0155242, 0144417, 0040000,}; + +/* 5.7721566490153286060651209008240243104215933593992E-1 */ +unsigned short eeul[NE] = { +0xd1be,0xc7a4,0076660,0063743,0111704,0x3ffe,}; + +#else + +/* 0.0 */ +unsigned short ezero[NE] = { +0, 0000000,0000000,0000000,0000000,0000000,}; +/* 5.0E-1 */ +unsigned short ehalf[NE] = { +0, 0000000,0000000,0000000,0100000,0x3ffe,}; +/* 1.0E0 */ +unsigned short eone[NE] = { +0, 0000000,0000000,0000000,0100000,0x3fff,}; +/* 2.0E0 */ +unsigned short etwo[NE] = { +0, 0000000,0000000,0000000,0100000,0040000,}; +/* 3.2E1 */ +unsigned short e32[NE] = { +0, 0000000,0000000,0000000,0100000,0040004,}; +/* 6.93147180559945309417232121458176568075500134360255E-1 */ +unsigned short elog2[NE] = { +0xc9e4,0x79ab,0150717,0013767,0130562,0x3ffe,}; +/* 1.41421356237309504880168872420969807856967187537695E0 */ +unsigned short esqrt2[NE] = { +0x597e,0x6484,0174736,0171463,0132404,0x3fff,}; +/* 2/sqrt(PI) = + * 1.12837916709551257389615890312154517168810125865800E0 */ +unsigned short eoneopi[NE] = { +0x71d5,0x688d,0012333,0135202,0110156,0x3fff,}; +/* 3.14159265358979323846264338327950288419716939937511E0 */ +unsigned short epi[NE] = { +0xc4c6,0xc234,0020550,0155242,0144417,0040000,}; +/* 5.7721566490153286060651209008240243104215933593992E-1 */ +unsigned short eeul[NE] = { +0xd1be,0xc7a4,0076660,0063743,0111704,0x3ffe,}; +#endif +extern unsigned short ezero[]; +extern unsigned short ehalf[]; +extern unsigned short eone[]; +extern unsigned short etwo[]; +extern unsigned short e32[]; +extern unsigned short elog2[]; +extern unsigned short esqrt2[]; +extern unsigned short eoneopi[]; +extern unsigned short epi[]; +extern unsigned short eeul[]; + diff --git a/regress/lib/libc/cephes/eexp.c b/regress/lib/libc/cephes/eexp.c new file mode 100644 index 00000000000..74f0d6adb33 --- /dev/null +++ b/regress/lib/libc/cephes/eexp.c @@ -0,0 +1,86 @@ +/* $OpenBSD: eexp.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* xexp.c */ +/* exponential function check routine */ +/* by Stephen L. Moshier. */ + + +#include "ehead.h" + +void eexp( x, y ) +unsigned short *x, *y; +{ +unsigned short num[NE], den[NE], x2[NE]; +long i; +unsigned short sign, expchk; + +/* range reduction theory: x = i + f, 0<=f<1; + * e**x = e**i * e**f + * e**i = 2**(i/log 2). + * Let i/log2 = i1 + f1, 0<=f1<1. + * Then e**i = 2**i1 * 2**f1, so + * e**x = 2**i1 * e**(log 2 * f1) * e**f. + */ +if( ecmp(x, ezero) == 0 ) + { + emov( eone, y ); + return; + } +emov(x, x2); +expchk = x2[NE-1]; +sign = expchk & 0x8000; +x2[NE-1] &= 0x7fff; + +/* Test for excessively large argument */ +expchk &= 0x7fff; +if( expchk > (EXONE + 15) ) + { + eclear( y ); + if( sign == 0 ) + einfin( y ); + return; + } + +eifrac( x2, &i, num ); /* x = i + f */ + +if( i != 0 ) + { + ltoe( &i, den ); /* floating point i */ + ediv( elog2, den, den ); /* i/log 2 */ + eifrac( den, &i, den ); /* i/log 2 = i1 + f1 */ + emul( elog2, den, den ); /* log 2 * f1 */ + eadd( den, num, x2 ); /* log 2 * f1 + f */ + } + +/*x2[NE-1] -= 1;*/ +eldexp( x2, -1L, x2 ); /* divide by 2 */ +etanh( x2, x2 ); /* tanh( x/2 ) */ +eadd( x2, eone, num ); /* 1 + tanh */ +eneg( x2 ); +eadd( x2, eone, den ); /* 1 - tanh */ +ediv( den, num, y ); /* (1 + tanh)/(1 - tanh) */ + +/*y[NE-1] += i;*/ +if( sign ) + { + ediv( y, eone, y ); + i = -i; + } +eldexp( y, i, y ); /* multiply by 2**i */ +} diff --git a/regress/lib/libc/cephes/ehead.h b/regress/lib/libc/cephes/ehead.h new file mode 100644 index 00000000000..009bcf89cc0 --- /dev/null +++ b/regress/lib/libc/cephes/ehead.h @@ -0,0 +1,59 @@ +/* $OpenBSD: ehead.h,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* Include file for extended precision arithmetic programs. + */ + +/* Number of 16 bit words in external x type format */ +#define NE 10 + +/* Number of 16 bit words in internal format */ +#define NI (NE+3) + +/* Array offset to exponent */ +#define E 1 + +/* Array offset to high guard word */ +#define M 2 + +/* Number of bits of precision */ +#define NBITS ((NI-4)*16) + +/* Maximum number of decimal digits in ASCII conversion + * = NBITS*log10(2) + */ +#define NDEC (NBITS*8/27) + +/* The exponent of 1.0 */ +#define EXONE (0x3fff) + +void eadd(), esub(), emul(), ediv(); +int ecmp(), enormlz(), eshift(); +void eshup1(), eshup8(), eshup6(), eshdn1(), eshdn8(), eshdn6(); +void eabs(), eneg(), emov(), eclear(), einfin(), efloor(); +void eldexp(), efrexp(), eifrac(), ltoe(); +void esqrt(), elog(), eexp(), etanh(), epow(); +void asctoe(), asctoe24(), asctoe53(), asctoe64(); +void etoasc(), e24toasc(), e53toasc(), e64toasc(); +void etoe64(), etoe53(), etoe24(), e64toe(), e53toe(), e24toe(); +int mtherr(); +extern unsigned short ezero[], ehalf[], eone[], etwo[]; +extern unsigned short elog2[], esqrt2[]; + + +/* by Stephen L. Moshier. */ diff --git a/regress/lib/libc/cephes/elog.c b/regress/lib/libc/cephes/elog.c new file mode 100644 index 00000000000..079cc754f48 --- /dev/null +++ b/regress/lib/libc/cephes/elog.c @@ -0,0 +1,110 @@ +/* $OpenBSD: elog.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* xlog.c */ +/* natural logarithm */ +/* by Stephen L. Moshier. */ + +#include "mconf.h" +#include "ehead.h" + + + +void elog( x, y ) +unsigned short *x, *y; +{ +unsigned short xx[NE], z[NE], a[NE], b[NE], t[NE], qj[NE]; +long ex; +int fex; + + +if( x[NE-1] & (unsigned short )0x8000 ) + { + eclear(y); + mtherr( "elog", DOMAIN ); + return; + } +if( ecmp( x, ezero ) == 0 ) + { + einfin( y ); + eneg(y); + mtherr( "elog", SING ); + return; + } +if( ecmp( x, eone ) == 0 ) + { + eclear( y ); + return; + } + +/* range reduction: log x = log( 2**ex * m ) = ex * log2 + log m */ +efrexp( x, &fex, xx ); +/* +emov(x, xx ); +ex = xx[NX-1] & 0x7fff; +ex -= 0x3ffe; +xx[NX-1] = 0x3ffe; +*/ + +/* Adjust range to 1/sqrt(2), sqrt(2) */ +esqrt2[NE-1] -= 1; +if( ecmp( xx, esqrt2 ) < 0 ) + { + fex -= 1; + emul( xx, etwo, xx ); + } +esqrt2[NE-1] += 1; + +esub( eone, xx, a ); +if( a[NE-1] == 0 ) + { + eclear( y ); + goto logdon; + } +eadd( eone, xx, b ); +ediv( b, a, y ); /* store (x-1)/(x+1) in y */ + +emul( y, y, z ); + +emov( eone, a ); +emov( eone, b ); +emov( eone, qj ); +do + { + eadd( etwo, qj, qj ); /* 2 * i + 1 */ + emul( z, a, a ); + ediv( qj, a, t ); + eadd( t, b, b ); + } +while( ((b[NE-1] & 0x7fff) - (t[NE-1] & 0x7fff)) < NBITS ); + + +emul( b, y, y ); +emul( y, etwo, y ); + +logdon: + +/* now add log of 2**ex */ +if( fex != 0 ) + { + ex = fex; + ltoe( &ex, b ); + emul( elog2, b, b ); + eadd( b, y, y ); + } +} diff --git a/regress/lib/libc/cephes/epow.c b/regress/lib/libc/cephes/epow.c new file mode 100644 index 00000000000..646268fce7c --- /dev/null +++ b/regress/lib/libc/cephes/epow.c @@ -0,0 +1,187 @@ +/* $OpenBSD: epow.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* epow.c */ +/* power function: z = x**y */ +/* by Stephen L. Moshier. */ + + +#include "ehead.h" + +extern int rndprc; +void epowi(); + +void epow( x, y, z ) +unsigned short *x, *y, *z; +{ +unsigned short w[NE]; +int rndsav; +long li; + +efloor( y, w ); +if( ecmp(y,w) == 0 ) + { + eifrac( y, &li, w ); + if( li < 0 ) + li = -li; + if( (li < 0x7fffffff) && (li != 0x80000000) ) + { + epowi( x, y, z ); + return; + } + } +/* z = exp( y * log(x) ) */ +rndsav = rndprc; +rndprc = NBITS; +elog( x, w ); +emul( y, w, w ); +eexp( w, z ); +rndprc = rndsav; +emul( eone, z, z ); +} + + +/* y is integer valued. */ + +void epowi( x, y, z ) +unsigned short x[], y[], z[]; +{ +unsigned short w[NE]; +long li, lx; +unsigned long lu; +int rndsav; +unsigned short signx; +/* unsigned short signy; */ + +rndsav = rndprc; +eifrac( y, &li, w ); +if( li < 0 ) + lx = -li; +else + lx = li; + +if( (lx == 0x7fffffff) || (lx == 0x80000000) ) + { + epow( x, y, z ); + goto done; + } + +if( (x[NE-1] & (unsigned short )0x7fff) == 0 ) + { + if( li == 0 ) + { + emov( eone, z ); + return; + } + else if( li < 0 ) + { + einfin( z ); + return; + } + else + { + eclear( z ); + return; + } + } + +if( li == 0L ) + { + emov( eone, z ); + return; + } + +emov( x, w ); +signx = w[NE-1] & (unsigned short )0x8000; +w[NE-1] &= (unsigned short )0x7fff; + +/* Overflow detection */ +/* +lx = li * (w[NE-1] - 0x3fff); +if( lx > 16385L ) + { + einfin( z ); + mtherr( "epowi", OVERFLOW ); + goto done; + } +if( lx < -16450L ) + { + eclear( z ); + return; + } +*/ +rndprc = NBITS; + +if( li < 0 ) + { + lu = (unsigned int )( -li ); +/* signy = 0xffff;*/ + ediv( w, eone, w ); + } +else + { + lu = (unsigned int )li; +/* signy = 0;*/ + } + +/* First bit of the power */ +if( lu & 1 ) + { + emov( w, z ); + } +else + { + emov( eone, z ); + signx = 0; + } + + +lu >>= 1; +while( lu != 0L ) + { + emul( w, w, w ); /* arg to the 2-to-the-kth power */ + if( lu & 1L ) /* if that bit is set, then include in product */ + emul( w, z, z ); + lu >>= 1; + } + + +done: + +if( signx ) + eneg( z ); /* odd power of negative number */ + +/* +if( signy ) + { + if( ecmp( z, ezero ) != 0 ) + { + ediv( z, eone, z ); + } + else + { + einfin( z ); + printf( "epowi OVERFLOW\n" ); + } + } +*/ +rndprc = rndsav; +emul( eone, z, z ); +} + + diff --git a/regress/lib/libc/cephes/etanh.c b/regress/lib/libc/cephes/etanh.c new file mode 100644 index 00000000000..4ac5ff1c21e --- /dev/null +++ b/regress/lib/libc/cephes/etanh.c @@ -0,0 +1,70 @@ +/* $OpenBSD: etanh.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* xtanh.c */ +/* hyperbolic tangent check routine */ +/* this subroutine is used by the exponential function routine */ +/* by Stephen L. Moshier. */ + + + +#include "ehead.h" + + +void etanh( x, y ) +unsigned short *x, *y; +{ +unsigned short e[NE], r[NE], j[NE], xx[NE], m2[NE]; +short i, n; +long lj; + +emov( x, r ); +r[NE-1] &= (unsigned short )0x7fff; +if( ecmp(r, eone) >= 0 ) + { +/* tanh(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x)) + * Note eexp() calls xtanh, but with an argument less than (1 + log 2)/2. + */ + eexp( r, e ); + ediv( e, eone, r ); + esub( r, e, xx ); + eadd( r, e, j ); + ediv( j, xx, y ); + return; + } + +emov( etwo, m2 ); +eneg( m2 ); + +n = NBITS/8; /* Number of terms to do in the continued fraction */ +lj = 2 * n + 1; +ltoe( &lj, j ); + +emov( j, e ); +emul( x, x, xx ); + +/* continued fraction */ +for( i=0; i<n; i++) + { + ediv( e, xx, r ); + eadd( m2, j, j ); + eadd( r, j, e ); + } + +ediv( e, x, y ); +} diff --git a/regress/lib/libc/cephes/etodec.c b/regress/lib/libc/cephes/etodec.c new file mode 100644 index 00000000000..a15845efb67 --- /dev/null +++ b/regress/lib/libc/cephes/etodec.c @@ -0,0 +1,199 @@ +/* $OpenBSD: etodec.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "ehead.h" +void emovi(), emovo(), ecleaz(), eshdn8(), emdnorm(); +void todec(); +/* +; convert DEC double precision to e type +; double d; +; short e[NE]; +; dectoe( &d, e ); +*/ +void dectoe( d, e ) +unsigned short *d; +unsigned short *e; +{ +unsigned short y[NI]; +register unsigned short r, *p; + +ecleaz(y); /* start with a zero */ +p = y; /* point to our number */ +r = *d; /* get DEC exponent word */ +if( *d & (unsigned int )0x8000 ) + *p = 0xffff; /* fill in our sign */ +++p; /* bump pointer to our exponent word */ +r &= 0x7fff; /* strip the sign bit */ +if( r == 0 ) /* answer = 0 if high order DEC word = 0 */ + goto done; + + +r >>= 7; /* shift exponent word down 7 bits */ +r += EXONE - 0201; /* subtract DEC exponent offset */ + /* add our e type exponent offset */ +*p++ = r; /* to form our exponent */ + +r = *d++; /* now do the high order mantissa */ +r &= 0177; /* strip off the DEC exponent and sign bits */ +r |= 0200; /* the DEC understood high order mantissa bit */ +*p++ = r; /* put result in our high guard word */ + +*p++ = *d++; /* fill in the rest of our mantissa */ +*p++ = *d++; +*p = *d; + +eshdn8(y); /* shift our mantissa down 8 bits */ +done: +emovo( y, e ); +} + + + +/* +; convert e type to DEC double precision +; double d; +; short e[NE]; +; etodec( e, &d ); +*/ +#if 0 +static unsigned short decbit[NI] = {0,0,0,0,0,0,0200,0}; +void etodec( x, d ) +unsigned short *x, *d; +{ +unsigned short xi[NI]; +register unsigned short r; +int i, j; + +emovi( x, xi ); +*d = 0; +if( xi[0] != 0 ) + *d = 0100000; +r = xi[E]; +if( r < (EXONE - 128) ) + goto zout; +i = xi[M+4]; +if( (i & 0200) != 0 ) + { + if( (i & 0377) == 0200 ) + { + if( (i & 0400) != 0 ) + { + /* check all less significant bits */ + for( j=M+5; j<NI; j++ ) + { + if( xi[j] != 0 ) + goto yesrnd; + } + } + goto nornd; + } +yesrnd: + eaddm( decbit, xi ); + r -= enormlz(xi); + } + +nornd: + +r -= EXONE; +r += 0201; +if( r < 0 ) + { +zout: + *d++ = 0; + *d++ = 0; + *d++ = 0; + *d++ = 0; + return; + } +if( r >= 0377 ) + { + *d++ = 077777; + *d++ = -1; + *d++ = -1; + *d++ = -1; + return; + } +r &= 0377; +r <<= 7; +eshup8( xi ); +xi[M] &= 0177; +r |= xi[M]; +*d++ |= r; +*d++ = xi[M+1]; +*d++ = xi[M+2]; +*d++ = xi[M+3]; +} +#else + +extern int rndprc; + +void etodec( x, d ) +unsigned short *x, *d; +{ +unsigned short xi[NI]; +long exp; +int rndsav; + +emovi( x, xi ); +exp = (long )xi[E] - (EXONE - 0201); /* adjust exponent for offsets */ +/* round off to nearest or even */ +rndsav = rndprc; +rndprc = 56; +emdnorm( xi, 0, 0, exp, 64 ); +rndprc = rndsav; +todec( xi, d ); +} + +void todec( x, y ) +unsigned short *x, *y; +{ +unsigned short i; +unsigned short *p; + +p = x; +*y = 0; +if( *p++ ) + *y = 0100000; +i = *p++; +if( i == 0 ) + { + *y++ = 0; + *y++ = 0; + *y++ = 0; + *y++ = 0; + return; + } +if( i > 0377 ) + { + *y++ |= 077777; + *y++ = 0xffff; + *y++ = 0xffff; + *y++ = 0xffff; + return; + } +i &= 0377; +i <<= 7; +eshup8( x ); +x[M] &= 0177; +i |= x[M]; +*y++ |= i; +*y++ = x[M+1]; +*y++ = x[M+2]; +*y++ = x[M+3]; +} +#endif diff --git a/regress/lib/libc/cephes/ieee.c b/regress/lib/libc/cephes/ieee.c new file mode 100644 index 00000000000..e2b8aa7b992 --- /dev/null +++ b/regress/lib/libc/cephes/ieee.c @@ -0,0 +1,4153 @@ +/* $OpenBSD: ieee.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* ieee.c + * + * Extended precision IEEE binary floating point arithmetic routines + * + * Numbers are stored in C language as arrays of 16-bit unsigned + * short integers. The arguments of the routines are pointers to + * the arrays. + * + * + * External e type data structure, simulates Intel 8087 chip + * temporary real format but possibly with a larger significand: + * + * NE-1 significand words (least significant word first, + * most significant bit is normally set) + * exponent (value = EXONE for 1.0, + * top bit is the sign) + * + * + * Internal data structure of a number (a "word" is 16 bits): + * + * ei[0] sign word (0 for positive, 0xffff for negative) + * ei[1] biased exponent (value = EXONE for the number 1.0) + * ei[2] high guard word (always zero after normalization) + * ei[3] + * to ei[NI-2] significand (NI-4 significand words, + * most significant word first, + * most significant bit is set) + * ei[NI-1] low guard word (0x8000 bit is rounding place) + * + * + * + * Routines for external format numbers + * + * asctoe( string, e ) ASCII string to extended double e type + * asctoe64( string, &d ) ASCII string to long double + * asctoe53( string, &d ) ASCII string to double + * asctoe24( string, &f ) ASCII string to single + * asctoeg( string, e, prec ) ASCII string to specified precision + * e24toe( &f, e ) IEEE single precision to e type + * e53toe( &d, e ) IEEE double precision to e type + * e64toe( &d, e ) IEEE long double precision to e type + * eabs(e) absolute value + * eadd( a, b, c ) c = b + a + * eclear(e) e = 0 + * ecmp (a, b) Returns 1 if a > b, 0 if a == b, + * -1 if a < b, -2 if either a or b is a NaN. + * ediv( a, b, c ) c = b / a + * efloor( a, b ) truncate to integer, toward -infinity + * efrexp( a, exp, s ) extract exponent and significand + * eifrac( e, &l, frac ) e to long integer and e type fraction + * euifrac( e, &l, frac ) e to unsigned long integer and e type fraction + * einfin( e ) set e to infinity, leaving its sign alone + * eldexp( a, n, b ) multiply by 2**n + * emov( a, b ) b = a + * emul( a, b, c ) c = b * a + * eneg(e) e = -e + * eround( a, b ) b = nearest integer value to a + * esub( a, b, c ) c = b - a + * e24toasc( &f, str, n ) single to ASCII string, n digits after decimal + * e53toasc( &d, str, n ) double to ASCII string, n digits after decimal + * e64toasc( &d, str, n ) long double to ASCII string + * etoasc( e, str, n ) e to ASCII string, n digits after decimal + * etoe24( e, &f ) convert e type to IEEE single precision + * etoe53( e, &d ) convert e type to IEEE double precision + * etoe64( e, &d ) convert e type to IEEE long double precision + * ltoe( &l, e ) long (32 bit) integer to e type + * ultoe( &l, e ) unsigned long (32 bit) integer to e type + * eisneg( e ) 1 if sign bit of e != 0, else 0 + * eisinf( e ) 1 if e has maximum exponent (non-IEEE) + * or is infinite (IEEE) + * eisnan( e ) 1 if e is a NaN + * esqrt( a, b ) b = square root of a + * + * + * Routines for internal format numbers + * + * eaddm( ai, bi ) add significands, bi = bi + ai + * ecleaz(ei) ei = 0 + * ecleazs(ei) set ei = 0 but leave its sign alone + * ecmpm( ai, bi ) compare significands, return 1, 0, or -1 + * edivm( ai, bi ) divide significands, bi = bi / ai + * emdnorm(ai,l,s,exp) normalize and round off + * emovi( a, ai ) convert external a to internal ai + * emovo( ai, a ) convert internal ai to external a + * emovz( ai, bi ) bi = ai, low guard word of bi = 0 + * emulm( ai, bi ) multiply significands, bi = bi * ai + * enormlz(ei) left-justify the significand + * eshdn1( ai ) shift significand and guards down 1 bit + * eshdn8( ai ) shift down 8 bits + * eshdn6( ai ) shift down 16 bits + * eshift( ai, n ) shift ai n bits up (or down if n < 0) + * eshup1( ai ) shift significand and guards up 1 bit + * eshup8( ai ) shift up 8 bits + * eshup6( ai ) shift up 16 bits + * esubm( ai, bi ) subtract significands, bi = bi - ai + * + * + * The result is always normalized and rounded to NI-4 word precision + * after each arithmetic operation. + * + * Exception flags are NOT fully supported. + * + * Define INFINITY in mconf.h for support of infinity; otherwise a + * saturation arithmetic is implemented. + * + * Define NANS for support of Not-a-Number items; otherwise the + * arithmetic will never produce a NaN output, and might be confused + * by a NaN input. + * If NaN's are supported, the output of ecmp(a,b) is -2 if + * either a or b is a NaN. This means asking if(ecmp(a,b) < 0) + * may not be legitimate. Use if(ecmp(a,b) == -1) for less-than + * if in doubt. + * Signaling NaN's are NOT supported; they are treated the same + * as quiet NaN's. + * + * Denormals are always supported here where appropriate (e.g., not + * for conversion to DEC numbers). + */ + +/* + * Revision history: + * + * 5 Jan 84 PDP-11 assembly language version + * 2 Mar 86 fixed bug in asctoq() + * 6 Dec 86 C language version + * 30 Aug 88 100 digit version, improved rounding + * 15 May 92 80-bit long double support + * + * Author: S. L. Moshier. + */ + +#include <stdio.h> +#include "mconf.h" +#include "ehead.h" + +/* Change UNK into something else. */ +#ifdef UNK +#undef UNK +#if BIGENDIAN +#define MIEEE 1 +#else +#define IBMPC 1 +#endif +#endif + +/* NaN's require infinity support. */ +#ifdef NANS +#ifndef INFINITY +#define INFINITY +#endif +#endif + +/* This handles 64-bit long ints. */ +#define LONGBITS (8 * sizeof(long)) + +/* Control register for rounding precision. + * This can be set to 80 (if NE=6), 64, 56, 53, or 24 bits. + */ +int rndprc = NBITS; +extern int rndprc; + +void eaddm(), esubm(), emdnorm(), asctoeg(), enan(); +static void toe24(), toe53(), toe64(), toe113(); +void eremain(), einit(), eiremain(); +int ecmpm(), edivm(), emulm(), eisneg(), eisinf(); +void emovi(), emovo(), emovz(), ecleaz(), eadd1(); +void etodec(), todec(), dectoe(); +int eisnan(), eiisnan(); + + + +void einit() +{ +} + +/* +; Clear out entire external format number. +; +; unsigned short x[]; +; eclear( x ); +*/ + +void eclear( x ) +register unsigned short *x; +{ +register int i; + +for( i=0; i<NE; i++ ) + *x++ = 0; +} + + + +/* Move external format number from a to b. + * + * emov( a, b ); + */ + +void emov( a, b ) +register unsigned short *a, *b; +{ +register int i; + +for( i=0; i<NE; i++ ) + *b++ = *a++; +} + + +/* +; Absolute value of external format number +; +; short x[NE]; +; eabs( x ); +*/ + +void eabs(x) +unsigned short x[]; /* x is the memory address of a short */ +{ + +x[NE-1] &= 0x7fff; /* sign is top bit of last word of external format */ +} + + + + +/* +; Negate external format number +; +; unsigned short x[NE]; +; eneg( x ); +*/ + +void eneg(x) +unsigned short x[]; +{ + +#ifdef NANS +if( eisnan(x) ) + return; +#endif +x[NE-1] ^= 0x8000; /* Toggle the sign bit */ +} + + + +/* Return 1 if external format number is negative, + * else return zero. + */ +int eisneg(x) +unsigned short x[]; +{ + +#ifdef NANS +if( eisnan(x) ) + return( 0 ); +#endif +if( x[NE-1] & 0x8000 ) + return( 1 ); +else + return( 0 ); +} + + +/* Return 1 if external format number has maximum possible exponent, + * else return zero. + */ +int eisinf(x) +unsigned short x[]; +{ + +if( (x[NE-1] & 0x7fff) == 0x7fff ) + { +#ifdef NANS + if( eisnan(x) ) + return( 0 ); +#endif + return( 1 ); + } +else + return( 0 ); +} + +/* Check if e-type number is not a number. + */ +int eisnan(x) +unsigned short x[]; +{ + +#ifdef NANS +int i; +/* NaN has maximum exponent */ +if( (x[NE-1] & 0x7fff) != 0x7fff ) + return (0); +/* ... and non-zero significand field. */ +for( i=0; i<NE-1; i++ ) + { + if( *x++ != 0 ) + return (1); + } +#endif +return (0); +} + +/* +; Fill entire number, including exponent and significand, with +; largest possible number. These programs implement a saturation +; value that is an ordinary, legal number. A special value +; "infinity" may also be implemented; this would require tests +; for that value and implementation of special rules for arithmetic +; operations involving inifinity. +*/ + +void einfin(x) +register unsigned short *x; +{ +register int i; + +#ifdef INFINITY +for( i=0; i<NE-1; i++ ) + *x++ = 0; +*x |= 32767; +#else +for( i=0; i<NE-1; i++ ) + *x++ = 0xffff; +*x |= 32766; +if( rndprc < NBITS ) + { + if (rndprc == 113) + { + *(x - 9) = 0; + *(x - 8) = 0; + } + if( rndprc == 64 ) + { + *(x-5) = 0; + } + if( rndprc == 53 ) + { + *(x-4) = 0xf800; + } + else + { + *(x-4) = 0; + *(x-3) = 0; + *(x-2) = 0xff00; + } + } +#endif +} + + + +/* Move in external format number, + * converting it to internal format. + */ +void emovi( a, b ) +unsigned short *a, *b; +{ +register unsigned short *p, *q; +int i; + +q = b; +p = a + (NE-1); /* point to last word of external number */ +/* get the sign bit */ +if( *p & 0x8000 ) + *q++ = 0xffff; +else + *q++ = 0; +/* get the exponent */ +*q = *p--; +*q++ &= 0x7fff; /* delete the sign bit */ +#ifdef INFINITY +if( (*(q-1) & 0x7fff) == 0x7fff ) + { +#ifdef NANS + if( eisnan(a) ) + { + *q++ = 0; + for( i=3; i<NI; i++ ) + *q++ = *p--; + return; + } +#endif + for( i=2; i<NI; i++ ) + *q++ = 0; + return; + } +#endif +/* clear high guard word */ +*q++ = 0; +/* move in the significand */ +for( i=0; i<NE-1; i++ ) + *q++ = *p--; +/* clear low guard word */ +*q = 0; +} + + +/* Move internal format number out, + * converting it to external format. + */ +void emovo( a, b ) +unsigned short *a, *b; +{ +register unsigned short *p, *q; +unsigned short i; + +p = a; +q = b + (NE-1); /* point to output exponent */ +/* combine sign and exponent */ +i = *p++; +if( i ) + *q-- = *p++ | 0x8000; +else + *q-- = *p++; +#ifdef INFINITY +if( *(p-1) == 0x7fff ) + { +#ifdef NANS + if( eiisnan(a) ) + { + enan( b, NBITS ); + return; + } +#endif + einfin(b); + return; + } +#endif +/* skip over guard word */ +++p; +/* move the significand */ +for( i=0; i<NE-1; i++ ) + *q-- = *p++; +} + + + + +/* Clear out internal format number. + */ + +void ecleaz( xi ) +register unsigned short *xi; +{ +register int i; + +for( i=0; i<NI; i++ ) + *xi++ = 0; +} + +/* same, but don't touch the sign. */ + +void ecleazs( xi ) +register unsigned short *xi; +{ +register int i; + +++xi; +for(i=0; i<NI-1; i++) + *xi++ = 0; +} + + + + +/* Move internal format number from a to b. + */ +void emovz( a, b ) +register unsigned short *a, *b; +{ +register int i; + +for( i=0; i<NI-1; i++ ) + *b++ = *a++; +/* clear low guard word */ +*b = 0; +} + +/* Return nonzero if internal format number is a NaN. + */ + +int eiisnan (x) +unsigned short x[]; +{ +int i; + +if( (x[E] & 0x7fff) == 0x7fff ) + { + for( i=M+1; i<NI; i++ ) + { + if( x[i] != 0 ) + return(1); + } + } +return(0); +} + +#ifdef INFINITY +/* Return nonzero if internal format number is infinite. */ + +static int +eiisinf (x) + unsigned short x[]; +{ + +#ifdef NANS + if (eiisnan (x)) + return (0); +#endif + if ((x[E] & 0x7fff) == 0x7fff) + return (1); + return (0); +} +#endif + +/* +; Compare significands of numbers in internal format. +; Guard words are included in the comparison. +; +; unsigned short a[NI], b[NI]; +; cmpm( a, b ); +; +; for the significands: +; returns +1 if a > b +; 0 if a == b +; -1 if a < b +*/ +int ecmpm( a, b ) +register unsigned short *a, *b; +{ +int i; + +a += M; /* skip up to significand area */ +b += M; +for( i=M; i<NI; i++ ) + { + if( *a++ != *b++ ) + goto difrnt; + } +return(0); + +difrnt: +if( *(--a) > *(--b) ) + return(1); +else + return(-1); +} + + +/* +; Shift significand down by 1 bit +*/ + +void eshdn1(x) +register unsigned short *x; +{ +register unsigned short bits; +int i; + +x += M; /* point to significand area */ + +bits = 0; +for( i=M; i<NI; i++ ) + { + if( *x & 1 ) + bits |= 1; + *x >>= 1; + if( bits & 2 ) + *x |= 0x8000; + bits <<= 1; + ++x; + } +} + + + +/* +; Shift significand up by 1 bit +*/ + +void eshup1(x) +register unsigned short *x; +{ +register unsigned short bits; +int i; + +x += NI-1; +bits = 0; + +for( i=M; i<NI; i++ ) + { + if( *x & 0x8000 ) + bits |= 1; + *x <<= 1; + if( bits & 2 ) + *x |= 1; + bits <<= 1; + --x; + } +} + + + +/* +; Shift significand down by 8 bits +*/ + +void eshdn8(x) +register unsigned short *x; +{ +register unsigned short newbyt, oldbyt; +int i; + +x += M; +oldbyt = 0; +for( i=M; i<NI; i++ ) + { + newbyt = *x << 8; + *x >>= 8; + *x |= oldbyt; + oldbyt = newbyt; + ++x; + } +} + +/* +; Shift significand up by 8 bits +*/ + +void eshup8(x) +register unsigned short *x; +{ +int i; +register unsigned short newbyt, oldbyt; + +x += NI-1; +oldbyt = 0; + +for( i=M; i<NI; i++ ) + { + newbyt = *x >> 8; + *x <<= 8; + *x |= oldbyt; + oldbyt = newbyt; + --x; + } +} + +/* +; Shift significand up by 16 bits +*/ + +void eshup6(x) +register unsigned short *x; +{ +int i; +register unsigned short *p; + +p = x + M; +x += M + 1; + +for( i=M; i<NI-1; i++ ) + *p++ = *x++; + +*p = 0; +} + +/* +; Shift significand down by 16 bits +*/ + +void eshdn6(x) +register unsigned short *x; +{ +int i; +register unsigned short *p; + +x += NI-1; +p = x + 1; + +for( i=M; i<NI-1; i++ ) + *(--p) = *(--x); + +*(--p) = 0; +} + +/* +; Add significands +; x + y replaces y +*/ + +void eaddm( x, y ) +unsigned short *x, *y; +{ +register unsigned long a; +int i; +unsigned int carry; + +x += NI-1; +y += NI-1; +carry = 0; +for( i=M; i<NI; i++ ) + { + a = (unsigned long )(*x) + (unsigned long )(*y) + carry; + if( a & 0x10000 ) + carry = 1; + else + carry = 0; + *y = (unsigned short )a; + --x; + --y; + } +} + +/* +; Subtract significands +; y - x replaces y +*/ + +void esubm( x, y ) +unsigned short *x, *y; +{ +unsigned long a; +int i; +unsigned int carry; + +x += NI-1; +y += NI-1; +carry = 0; +for( i=M; i<NI; i++ ) + { + a = (unsigned long )(*y) - (unsigned long )(*x) - carry; + if( a & 0x10000 ) + carry = 1; + else + carry = 0; + *y = (unsigned short )a; + --x; + --y; + } +} + + +/* Divide significands */ + +static unsigned short equot[NI] = {0}; /* was static */ + +#if 0 +int edivm( den, num ) +unsigned short den[], num[]; +{ +int i; +register unsigned short *p, *q; +unsigned short j; + +p = &equot[0]; +*p++ = num[0]; +*p++ = num[1]; + +for( i=M; i<NI; i++ ) + { + *p++ = 0; + } + +/* Use faster compare and subtraction if denominator + * has only 15 bits of significance. + */ +p = &den[M+2]; +if( *p++ == 0 ) + { + for( i=M+3; i<NI; i++ ) + { + if( *p++ != 0 ) + goto fulldiv; + } + if( (den[M+1] & 1) != 0 ) + goto fulldiv; + eshdn1(num); + eshdn1(den); + + p = &den[M+1]; + q = &num[M+1]; + + for( i=0; i<NBITS+2; i++ ) + { + if( *p <= *q ) + { + *q -= *p; + j = 1; + } + else + { + j = 0; + } + eshup1(equot); + equot[NI-2] |= j; + eshup1(num); + } + goto divdon; + } + +/* The number of quotient bits to calculate is + * NBITS + 1 scaling guard bit + 1 roundoff bit. + */ +fulldiv: + +p = &equot[NI-2]; +for( i=0; i<NBITS+2; i++ ) + { + if( ecmpm(den,num) <= 0 ) + { + esubm(den, num); + j = 1; /* quotient bit = 1 */ + } + else + j = 0; + eshup1(equot); + *p |= j; + eshup1(num); + } + +divdon: + +eshdn1( equot ); +eshdn1( equot ); + +/* test for nonzero remainder after roundoff bit */ +p = &num[M]; +j = 0; +for( i=M; i<NI; i++ ) + { + j |= *p++; + } +if( j ) + j = 1; + + +for( i=0; i<NI; i++ ) + num[i] = equot[i]; +return( (int )j ); +} + +/* Multiply significands */ +int emulm( a, b ) +unsigned short a[], b[]; +{ +unsigned short *p, *q; +int i, j, k; + +equot[0] = b[0]; +equot[1] = b[1]; +for( i=M; i<NI; i++ ) + equot[i] = 0; + +p = &a[NI-2]; +k = NBITS; +while( *p == 0 ) /* significand is not supposed to be all zero */ + { + eshdn6(a); + k -= 16; + } +if( (*p & 0xff) == 0 ) + { + eshdn8(a); + k -= 8; + } + +q = &equot[NI-1]; +j = 0; +for( i=0; i<k; i++ ) + { + if( *p & 1 ) + eaddm(b, equot); +/* remember if there were any nonzero bits shifted out */ + if( *q & 1 ) + j |= 1; + eshdn1(a); + eshdn1(equot); + } + +for( i=0; i<NI; i++ ) + b[i] = equot[i]; + +/* return flag for lost nonzero bits */ +return(j); +} + +#else + +/* Multiply significand of e-type number b +by 16-bit quantity a, e-type result to c. */ + +void m16m( a, b, c ) +unsigned short a; +unsigned short b[], c[]; +{ +register unsigned short *pp; +register unsigned long carry; +unsigned short *ps; +unsigned short p[NI]; +unsigned long aa, m; +int i; + +aa = a; +pp = &p[NI-2]; +*pp++ = 0; +*pp = 0; +ps = &b[NI-1]; + +for( i=M+1; i<NI; i++ ) + { + if( *ps == 0 ) + { + --ps; + --pp; + *(pp-1) = 0; + } + else + { + m = (unsigned long) aa * *ps--; + carry = (m & 0xffff) + *pp; + *pp-- = (unsigned short )carry; + carry = (carry >> 16) + (m >> 16) + *pp; + *pp = (unsigned short )carry; + *(pp-1) = carry >> 16; + } + } +for( i=M; i<NI; i++ ) + c[i] = p[i]; +} + + +/* Divide significands. Neither the numerator nor the denominator +is permitted to have its high guard word nonzero. */ + + +int edivm( den, num ) +unsigned short den[], num[]; +{ +int i; +register unsigned short *p; +unsigned long tnum; +unsigned short j, tdenm, tquot; +unsigned short tprod[NI+1]; + +p = &equot[0]; +*p++ = num[0]; +*p++ = num[1]; + +for( i=M; i<NI; i++ ) + { + *p++ = 0; + } +eshdn1( num ); +tdenm = den[M+1]; +for( i=M; i<NI; i++ ) + { + /* Find trial quotient digit (the radix is 65536). */ + tnum = (((unsigned long) num[M]) << 16) + num[M+1]; + + /* Do not execute the divide instruction if it will overflow. */ + if( (tdenm * 0xffffL) < tnum ) + tquot = 0xffff; + else + tquot = tnum / tdenm; + + /* Prove that the divide worked. */ +/* + tcheck = (unsigned long )tquot * tdenm; + if( tnum - tcheck > tdenm ) + tquot = 0xffff; +*/ + /* Multiply denominator by trial quotient digit. */ + m16m( tquot, den, tprod ); + /* The quotient digit may have been overestimated. */ + if( ecmpm( tprod, num ) > 0 ) + { + tquot -= 1; + esubm( den, tprod ); + if( ecmpm( tprod, num ) > 0 ) + { + tquot -= 1; + esubm( den, tprod ); + } + } +/* + if( ecmpm( tprod, num ) > 0 ) + { + eshow( "tprod", tprod ); + eshow( "num ", num ); + printf( "tnum = %08lx, tden = %04x, tquot = %04x\n", + tnum, den[M+1], tquot ); + } +*/ + esubm( tprod, num ); +/* + if( ecmpm( num, den ) >= 0 ) + { + eshow( "num ", num ); + eshow( "den ", den ); + printf( "tnum = %08lx, tden = %04x, tquot = %04x\n", + tnum, den[M+1], tquot ); + } +*/ + equot[i] = tquot; + eshup6(num); + } +/* test for nonzero remainder after roundoff bit */ +p = &num[M]; +j = 0; +for( i=M; i<NI; i++ ) + { + j |= *p++; + } +if( j ) + j = 1; + +for( i=0; i<NI; i++ ) + num[i] = equot[i]; + +return( (int )j ); +} + + + +/* Multiply significands */ +int emulm( a, b ) +unsigned short a[], b[]; +{ +unsigned short *p, *q; +unsigned short pprod[NI]; +unsigned short j; +int i; + +equot[0] = b[0]; +equot[1] = b[1]; +for( i=M; i<NI; i++ ) + equot[i] = 0; + +j = 0; +p = &a[NI-1]; +q = &equot[NI-1]; +for( i=M+1; i<NI; i++ ) + { + if( *p == 0 ) + { + --p; + } + else + { + m16m( *p--, b, pprod ); + eaddm(pprod, equot); + } + j |= *q; + eshdn6(equot); + } + +for( i=0; i<NI; i++ ) + b[i] = equot[i]; + +/* return flag for lost nonzero bits */ +return( (int)j ); +} + + +/* +eshow(str, x) +char *str; +unsigned short *x; +{ +int i; + +printf( "%s ", str ); +for( i=0; i<NI; i++ ) + printf( "%04x ", *x++ ); +printf( "\n" ); +} +*/ +#endif + + + +/* + * Normalize and round off. + * + * The internal format number to be rounded is "s". + * Input "lost" indicates whether the number is exact. + * This is the so-called sticky bit. + * + * Input "subflg" indicates whether the number was obtained + * by a subtraction operation. In that case if lost is nonzero + * then the number is slightly smaller than indicated. + * + * Input "exp" is the biased exponent, which may be negative. + * the exponent field of "s" is ignored but is replaced by + * "exp" as adjusted by normalization and rounding. + * + * Input "rcntrl" is the rounding control. + */ + +static int rlast = -1; +static int rw = 0; +static unsigned short rmsk = 0; +static unsigned short rmbit = 0; +static unsigned short rebit = 0; +static int re = 0; +static unsigned short rbit[NI] = {0,0,0,0,0,0,0,0}; + +void emdnorm( s, lost, subflg, exp, rcntrl ) +unsigned short s[]; +int lost; +int subflg; +long exp; +int rcntrl; +{ +int i, j; +unsigned short r; + +/* Normalize */ +j = enormlz( s ); + +/* a blank significand could mean either zero or infinity. */ +#ifndef INFINITY +if( j > NBITS ) + { + ecleazs( s ); + return; + } +#endif +exp -= j; +#ifndef INFINITY +if( exp >= 32767L ) + goto overf; +#else +if( (j > NBITS) && (exp < 32767L) ) + { + ecleazs( s ); + return; + } +#endif +if( exp < 0L ) + { + if( exp > (long )(-NBITS-1) ) + { + j = (int )exp; + i = eshift( s, j ); + if( i ) + lost = 1; + } + else + { + ecleazs( s ); + return; + } + } +/* Round off, unless told not to by rcntrl. */ +if( rcntrl == 0 ) + goto mdfin; +/* Set up rounding parameters if the control register changed. */ +if( rndprc != rlast ) + { + ecleaz( rbit ); + switch( rndprc ) + { + default: + case NBITS: + rw = NI-1; /* low guard word */ + rmsk = 0xffff; + rmbit = 0x8000; + rebit = 1; + re = rw - 1; + break; + case 113: + rw = 10; + rmsk = 0x7fff; + rmbit = 0x4000; + rebit = 0x8000; + re = rw; + break; + case 64: + rw = 7; + rmsk = 0xffff; + rmbit = 0x8000; + rebit = 1; + re = rw-1; + break; +/* For DEC arithmetic */ + case 56: + rw = 6; + rmsk = 0xff; + rmbit = 0x80; + rebit = 0x100; + re = rw; + break; + case 53: + rw = 6; + rmsk = 0x7ff; + rmbit = 0x0400; + rebit = 0x800; + re = rw; + break; + case 24: + rw = 4; + rmsk = 0xff; + rmbit = 0x80; + rebit = 0x100; + re = rw; + break; + } + rbit[re] = rebit; + rlast = rndprc; + } + +/* Shift down 1 temporarily if the data structure has an implied + * most significant bit and the number is denormal. + * For rndprc = 64 or NBITS, there is no implied bit. + * But Intel long double denormals lose one bit of significance even so. + */ +#ifdef IBMPC +if( (exp <= 0) && (rndprc != NBITS) ) +#else +if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) ) +#endif + { + lost |= s[NI-1] & 1; + eshdn1(s); + } +/* Clear out all bits below the rounding bit, + * remembering in r if any were nonzero. + */ +r = s[rw] & rmsk; +if( rndprc < NBITS ) + { + i = rw + 1; + while( i < NI ) + { + if( s[i] ) + r |= 1; + s[i] = 0; + ++i; + } + } +s[rw] &= ~rmsk; +if( (r & rmbit) != 0 ) + { + if( r == rmbit ) + { + if( lost == 0 ) + { /* round to even */ + if( (s[re] & rebit) == 0 ) + goto mddone; + } + else + { + if( subflg != 0 ) + goto mddone; + } + } + eaddm( rbit, s ); + } +mddone: +#ifdef IBMPC +if( (exp <= 0) && (rndprc != NBITS) ) +#else +if( (exp <= 0) && (rndprc != 64) && (rndprc != NBITS) ) +#endif + { + eshup1(s); + } +if( s[2] != 0 ) + { /* overflow on roundoff */ + eshdn1(s); + exp += 1; + } +mdfin: +s[NI-1] = 0; +if( exp >= 32767L ) + { +#ifndef INFINITY +overf: +#endif +#ifdef INFINITY + s[1] = 32767; + for( i=2; i<NI-1; i++ ) + s[i] = 0; +#else + s[1] = 32766; + s[2] = 0; + for( i=M+1; i<NI-1; i++ ) + s[i] = 0xffff; + s[NI-1] = 0; + if( (rndprc < 64) || (rndprc == 113) ) + { + s[rw] &= ~rmsk; + if( rndprc == 24 ) + { + s[5] = 0; + s[6] = 0; + } + } +#endif + return; + } +if( exp < 0 ) + s[1] = 0; +else + s[1] = (unsigned short )exp; +} + + + +/* +; Subtract external format numbers. +; +; unsigned short a[NE], b[NE], c[NE]; +; esub( a, b, c ); c = b - a +*/ + +static int subflg = 0; + +void esub( a, b, c ) +unsigned short *a, *b, *c; +{ + +#ifdef NANS +if( eisnan(a) ) + { + emov (a, c); + return; + } +if( eisnan(b) ) + { + emov(b,c); + return; + } +/* Infinity minus infinity is a NaN. + * Test for subtracting infinities of the same sign. + */ +if( eisinf(a) && eisinf(b) && ((eisneg (a) ^ eisneg (b)) == 0)) + { + mtherr( "esub", DOMAIN ); + enan( c, NBITS ); + return; + } +#endif +subflg = 1; +eadd1( a, b, c ); +} + + +/* +; Add. +; +; unsigned short a[NE], b[NE], c[NE]; +; eadd( a, b, c ); c = b + a +*/ +void eadd( a, b, c ) +unsigned short *a, *b, *c; +{ + +#ifdef NANS +/* NaN plus anything is a NaN. */ +if( eisnan(a) ) + { + emov(a,c); + return; + } +if( eisnan(b) ) + { + emov(b,c); + return; + } +/* Infinity minus infinity is a NaN. + * Test for adding infinities of opposite signs. + */ +if( eisinf(a) && eisinf(b) + && ((eisneg(a) ^ eisneg(b)) != 0) ) + { + mtherr( "eadd", DOMAIN ); + enan( c, NBITS ); + return; + } +#endif +subflg = 0; +eadd1( a, b, c ); +} + +void eadd1( a, b, c ) +unsigned short *a, *b, *c; +{ +unsigned short ai[NI], bi[NI], ci[NI]; +int i, lost, j, k; +long lt, lta, ltb; + +#ifdef INFINITY +if( eisinf(a) ) + { + emov(a,c); + if( subflg ) + eneg(c); + return; + } +if( eisinf(b) ) + { + emov(b,c); + return; + } +#endif +emovi( a, ai ); +emovi( b, bi ); +if( subflg ) + ai[0] = ~ai[0]; + +/* compare exponents */ +lta = ai[E]; +ltb = bi[E]; +lt = lta - ltb; +if( lt > 0L ) + { /* put the larger number in bi */ + emovz( bi, ci ); + emovz( ai, bi ); + emovz( ci, ai ); + ltb = bi[E]; + lt = -lt; + } +lost = 0; +if( lt != 0L ) + { + if( lt < (long )(-NBITS-1) ) + goto done; /* answer same as larger addend */ + k = (int )lt; + lost = eshift( ai, k ); /* shift the smaller number down */ + } +else + { +/* exponents were the same, so must compare significands */ + i = ecmpm( ai, bi ); + if( i == 0 ) + { /* the numbers are identical in magnitude */ + /* if different signs, result is zero */ + if( ai[0] != bi[0] ) + { + eclear(c); + return; + } + /* if same sign, result is double */ + /* double denomalized tiny number */ + if( (bi[E] == 0) && ((bi[3] & 0x8000) == 0) ) + { + eshup1( bi ); + goto done; + } + /* add 1 to exponent unless both are zero! */ + for( j=1; j<NI-1; j++ ) + { + if( bi[j] != 0 ) + { + ltb += 1; + if( ltb >= 0x7fff ) + { + eclear(c); + einfin(c); + if( ai[0] != 0 ) + eneg(c); + return; + } + break; + } + } + bi[E] = (unsigned short )ltb; + goto done; + } + if( i > 0 ) + { /* put the larger number in bi */ + emovz( bi, ci ); + emovz( ai, bi ); + emovz( ci, ai ); + } + } +if( ai[0] == bi[0] ) + { + eaddm( ai, bi ); + subflg = 0; + } +else + { + esubm( ai, bi ); + subflg = 1; + } +emdnorm( bi, lost, subflg, ltb, 64 ); + +done: +emovo( bi, c ); +} + + + +/* +; Divide. +; +; unsigned short a[NE], b[NE], c[NE]; +; ediv( a, b, c ); c = b / a +*/ +void ediv( a, b, c ) +unsigned short *a, *b, *c; +{ +unsigned short ai[NI], bi[NI]; +int i, sign; +long lt, lta, ltb; + +/* IEEE says if result is not a NaN, the sign is "-" if and only if + operands have opposite signs -- but flush -0 to 0 later if not IEEE. */ +sign = eisneg(a) ^ eisneg(b); + +#ifdef NANS +/* Return any NaN input. */ +if( eisnan(a) ) + { + emov(a,c); + return; + } +if( eisnan(b) ) + { + emov(b,c); + return; + } +/* Zero over zero, or infinity over infinity, is a NaN. */ +if( ((ecmp(a,ezero) == 0) && (ecmp(b,ezero) == 0)) + || (eisinf (a) && eisinf (b)) ) + { + mtherr( "ediv", DOMAIN ); + enan( c, NBITS ); + return; + } +#endif +/* Infinity over anything else is infinity. */ +#ifdef INFINITY +if( eisinf(b) ) + { + einfin(c); + goto divsign; + } +if( eisinf(a) ) + { + eclear(c); + goto divsign; + } +#endif +emovi( a, ai ); +emovi( b, bi ); +lta = ai[E]; +ltb = bi[E]; +if( bi[E] == 0 ) + { /* See if numerator is zero. */ + for( i=1; i<NI-1; i++ ) + { + if( bi[i] != 0 ) + { + ltb -= enormlz( bi ); + goto dnzro1; + } + } + eclear(c); + goto divsign; + } +dnzro1: + +if( ai[E] == 0 ) + { /* possible divide by zero */ + for( i=1; i<NI-1; i++ ) + { + if( ai[i] != 0 ) + { + lta -= enormlz( ai ); + goto dnzro2; + } + } + einfin(c); + mtherr( "ediv", SING ); + goto divsign; + } +dnzro2: + +i = edivm( ai, bi ); +/* calculate exponent */ +lt = ltb - lta + EXONE; +emdnorm( bi, i, 0, lt, 64 ); +emovo( bi, c ); + +divsign: + +if( sign ) + *(c+(NE-1)) |= 0x8000; +else + *(c+(NE-1)) &= ~0x8000; +} + + + +/* +; Multiply. +; +; unsigned short a[NE], b[NE], c[NE]; +; emul( a, b, c ); c = b * a +*/ +void emul( a, b, c ) +unsigned short *a, *b, *c; +{ +unsigned short ai[NI], bi[NI]; +int i, j, sign; +long lt, lta, ltb; + +/* IEEE says if result is not a NaN, the sign is "-" if and only if + operands have opposite signs -- but flush -0 to 0 later if not IEEE. */ +sign = eisneg(a) ^ eisneg(b); + +#ifdef NANS +/* NaN times anything is the same NaN. */ +if( eisnan(a) ) + { + emov(a,c); + return; + } +if( eisnan(b) ) + { + emov(b,c); + return; + } +/* Zero times infinity is a NaN. */ +if( (eisinf(a) && (ecmp(b,ezero) == 0)) + || (eisinf(b) && (ecmp(a,ezero) == 0)) ) + { + mtherr( "emul", DOMAIN ); + enan( c, NBITS ); + return; + } +#endif +/* Infinity times anything else is infinity. */ +#ifdef INFINITY +if( eisinf(a) || eisinf(b) ) + { + einfin(c); + goto mulsign; + } +#endif +emovi( a, ai ); +emovi( b, bi ); +lta = ai[E]; +ltb = bi[E]; +if( ai[E] == 0 ) + { + for( i=1; i<NI-1; i++ ) + { + if( ai[i] != 0 ) + { + lta -= enormlz( ai ); + goto mnzer1; + } + } + eclear(c); + goto mulsign; + } +mnzer1: + +if( bi[E] == 0 ) + { + for( i=1; i<NI-1; i++ ) + { + if( bi[i] != 0 ) + { + ltb -= enormlz( bi ); + goto mnzer2; + } + } + eclear(c); + goto mulsign; + } +mnzer2: + +/* Multiply significands */ +j = emulm( ai, bi ); +/* calculate exponent */ +lt = lta + ltb - (EXONE - 1); +emdnorm( bi, j, 0, lt, 64 ); +emovo( bi, c ); +/* IEEE says sign is "-" if and only if operands have opposite signs. */ +mulsign: +if( sign ) + *(c+(NE-1)) |= 0x8000; +else + *(c+(NE-1)) &= ~0x8000; +} + + + + +/* +; Convert IEEE double precision to e type +; double d; +; unsigned short x[N+2]; +; e53toe( &d, x ); +*/ +void e53toe( pe, y ) +unsigned short *pe, *y; +{ +#ifdef DEC + +dectoe( pe, y ); /* see etodec.c */ + +#else + +register unsigned short r; +register unsigned short *p, *e; +unsigned short yy[NI]; +int denorm, k; + +e = pe; +denorm = 0; /* flag if denormalized number */ +ecleaz(yy); +#ifdef IBMPC +e += 3; +#endif +r = *e; +yy[0] = 0; +if( r & 0x8000 ) + yy[0] = 0xffff; +yy[M] = (r & 0x0f) | 0x10; +r &= ~0x800f; /* strip sign and 4 significand bits */ +#ifdef INFINITY +if( r == 0x7ff0 ) + { +#ifdef NANS +#ifdef IBMPC + if( ((pe[3] & 0xf) != 0) || (pe[2] != 0) + || (pe[1] != 0) || (pe[0] != 0) ) + { + enan( y, NBITS ); + return; + } +#else + if( ((pe[0] & 0xf) != 0) || (pe[1] != 0) + || (pe[2] != 0) || (pe[3] != 0) ) + { + enan( y, NBITS ); + return; + } +#endif +#endif /* NANS */ + eclear( y ); + einfin( y ); + if( yy[0] ) + eneg(y); + return; + } +#endif +r >>= 4; +/* If zero exponent, then the significand is denormalized. + * So, take back the understood high significand bit. */ +if( r == 0 ) + { + denorm = 1; + yy[M] &= ~0x10; + } +r += EXONE - 01777; +yy[E] = r; +p = &yy[M+1]; +#ifdef IBMPC +*p++ = *(--e); +*p++ = *(--e); +*p++ = *(--e); +#endif +#ifdef MIEEE +++e; +*p++ = *e++; +*p++ = *e++; +*p++ = *e++; +#endif +(void )eshift( yy, -5 ); +if( denorm ) + { /* if zero exponent, then normalize the significand */ + if( (k = enormlz(yy)) > NBITS ) + ecleazs(yy); + else + yy[E] -= (unsigned short )(k-1); + } +emovo( yy, y ); +#endif /* not DEC */ +} + +void e64toe( pe, y ) +unsigned short *pe, *y; +{ +unsigned short yy[NI]; +unsigned short *p, *q, *e; +int i; + +e = pe; +p = yy; +for( i=0; i<NE-5; i++ ) + *p++ = 0; +#ifdef IBMPC +for( i=0; i<5; i++ ) + *p++ = *e++; +#endif +#ifdef DEC +for( i=0; i<5; i++ ) + *p++ = *e++; +#endif +#ifdef MIEEE +p = &yy[0] + (NE-1); +*p-- = *e++; +++e; +for( i=0; i<4; i++ ) + *p-- = *e++; +#endif + +#ifdef IBMPC +/* For Intel long double, shift denormal significand up 1 + -- but only if the top significand bit is zero. */ +if((yy[NE-1] & 0x7fff) == 0 && (yy[NE-2] & 0x8000) == 0) + { + unsigned short temp[NI+1]; + emovi(yy, temp); + eshup1(temp); + emovo(temp,y); + return; + } +#endif +#ifdef INFINITY +/* Point to the exponent field. */ +p = &yy[NE-1]; +if ((*p & 0x7fff) == 0x7fff) + { +#ifdef NANS +#ifdef IBMPC + for( i=0; i<4; i++ ) + { + if((i != 3 && pe[i] != 0) + /* Check for Intel long double infinity pattern. */ + || (i == 3 && pe[i] != 0x8000)) + { + enan( y, NBITS ); + return; + } + } +#else + /* In Motorola extended precision format, the most significant + bit of an infinity mantissa could be either 1 or 0. It is + the lower order bits that tell whether the value is a NaN. */ + if ((pe[2] & 0x7fff) != 0) + goto bigend_nan; + + for( i=3; i<=5; i++ ) + { + if( pe[i] != 0 ) + { +bigend_nan: + enan( y, NBITS ); + return; + } + } +#endif +#endif /* NANS */ + eclear( y ); + einfin( y ); + if( *p & 0x8000 ) + eneg(y); + return; + } +#endif +p = yy; +q = y; +for( i=0; i<NE; i++ ) + *q++ = *p++; +} + +void e113toe(pe,y) +unsigned short *pe, *y; +{ +register unsigned short r; +unsigned short *e, *p; +unsigned short yy[NI]; +int denorm, i; + +e = pe; +denorm = 0; +ecleaz(yy); +#ifdef IBMPC +e += 7; +#endif +r = *e; +yy[0] = 0; +if( r & 0x8000 ) + yy[0] = 0xffff; +r &= 0x7fff; +#ifdef INFINITY +if( r == 0x7fff ) + { +#ifdef NANS +#ifdef IBMPC + for( i=0; i<7; i++ ) + { + if( pe[i] != 0 ) + { + enan( y, NBITS ); + return; + } + } +#else + for( i=1; i<8; i++ ) + { + if( pe[i] != 0 ) + { + enan( y, NBITS ); + return; + } + } +#endif +#endif /* NANS */ + eclear( y ); + einfin( y ); + if( *e & 0x8000 ) + eneg(y); + return; + } +#endif /* INFINITY */ +yy[E] = r; +p = &yy[M + 1]; +#ifdef IBMPC +for( i=0; i<7; i++ ) + *p++ = *(--e); +#endif +#ifdef MIEEE +++e; +for( i=0; i<7; i++ ) + *p++ = *e++; +#endif +/* If denormal, remove the implied bit; else shift down 1. */ +if( r == 0 ) + { + yy[M] = 0; + } +else + { + yy[M] = 1; + eshift( yy, -1 ); + } +emovo(yy,y); +} + + +/* +; Convert IEEE single precision to e type +; float d; +; unsigned short x[N+2]; +; dtox( &d, x ); +*/ +void e24toe( pe, y ) +unsigned short *pe, *y; +{ +register unsigned short r; +register unsigned short *p, *e; +unsigned short yy[NI]; +int denorm, k; + +e = pe; +denorm = 0; /* flag if denormalized number */ +ecleaz(yy); +#ifdef IBMPC +e += 1; +#endif +#ifdef DEC +e += 1; +#endif +r = *e; +yy[0] = 0; +if( r & 0x8000 ) + yy[0] = 0xffff; +yy[M] = (r & 0x7f) | 0200; +r &= ~0x807f; /* strip sign and 7 significand bits */ +#ifdef INFINITY +if( r == 0x7f80 ) + { +#ifdef NANS +#ifdef MIEEE + if( ((pe[0] & 0x7f) != 0) || (pe[1] != 0) ) + { + enan( y, NBITS ); + return; + } +#else + if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) ) + { + enan( y, NBITS ); + return; + } +#endif +#endif /* NANS */ + eclear( y ); + einfin( y ); + if( yy[0] ) + eneg(y); + return; + } +#endif +r >>= 7; +/* If zero exponent, then the significand is denormalized. + * So, take back the understood high significand bit. */ +if( r == 0 ) + { + denorm = 1; + yy[M] &= ~0200; + } +r += EXONE - 0177; +yy[E] = r; +p = &yy[M+1]; +#ifdef IBMPC +*p++ = *(--e); +#endif +#ifdef DEC +*p++ = *(--e); +#endif +#ifdef MIEEE +++e; +*p++ = *e++; +#endif +(void )eshift( yy, -8 ); +if( denorm ) + { /* if zero exponent, then normalize the significand */ + if( (k = enormlz(yy)) > NBITS ) + ecleazs(yy); + else + yy[E] -= (unsigned short )(k-1); + } +emovo( yy, y ); +} + +void etoe113(x,e) +unsigned short *x, *e; +{ +unsigned short xi[NI]; +long exp; +int rndsav; + +#ifdef NANS +if( eisnan(x) ) + { + enan( e, 113 ); + return; + } +#endif +emovi( x, xi ); +exp = (long )xi[E]; +#ifdef INFINITY +if( eisinf(x) ) + goto nonorm; +#endif +/* round off to nearest or even */ +rndsav = rndprc; +rndprc = 113; +emdnorm( xi, 0, 0, exp, 64 ); +rndprc = rndsav; +nonorm: +toe113 (xi, e); +} + +/* move out internal format to ieee long double */ +static void toe113(a,b) +unsigned short *a, *b; +{ +register unsigned short *p, *q; +unsigned short i; + +#ifdef NANS +if( eiisnan(a) ) + { + enan( b, 113 ); + return; + } +#endif +p = a; +#ifdef MIEEE +q = b; +#else +q = b + 7; /* point to output exponent */ +#endif + +/* If not denormal, delete the implied bit. */ +if( a[E] != 0 ) + { + eshup1 (a); + } +/* combine sign and exponent */ +i = *p++; +#ifdef MIEEE +if( i ) + *q++ = *p++ | 0x8000; +else + *q++ = *p++; +#else +if( i ) + *q-- = *p++ | 0x8000; +else + *q-- = *p++; +#endif +/* skip over guard word */ +++p; +/* move the significand */ +#ifdef MIEEE +for (i = 0; i < 7; i++) + *q++ = *p++; +#else +for (i = 0; i < 7; i++) + *q-- = *p++; +#endif +} + + +void etoe64( x, e ) +unsigned short *x, *e; +{ +unsigned short xi[NI]; +long exp; +int rndsav; + +#ifdef NANS +if( eisnan(x) ) + { + enan( e, 64 ); + return; + } +#endif +emovi( x, xi ); +exp = (long )xi[E]; /* adjust exponent for offset */ +#ifdef INFINITY +if( eisinf(x) ) + goto nonorm; +#endif +/* round off to nearest or even */ +rndsav = rndprc; +rndprc = 64; +emdnorm( xi, 0, 0, exp, 64 ); +rndprc = rndsav; +nonorm: +toe64( xi, e ); +} + +/* move out internal format to ieee long double */ +static void toe64( a, b ) +unsigned short *a, *b; +{ +register unsigned short *p, *q; +unsigned short i; + +#ifdef NANS +if( eiisnan(a) ) + { + enan( b, 64 ); + return; + } +#endif +#ifdef IBMPC +/* Shift Intel denormal significand down 1. */ +if( a[E] == 0 ) + eshdn1(a); +#endif +p = a; +#ifdef MIEEE +q = b; +#else +q = b + 4; /* point to output exponent */ +#if 1 +/* NOTE: if data type is 96 bits wide, clear the last word here. */ +*(q+1)= 0; +#endif +#endif + +/* combine sign and exponent */ +i = *p++; +#ifdef MIEEE +if( i ) + *q++ = *p++ | 0x8000; +else + *q++ = *p++; +*q++ = 0; +#else +if( i ) + *q-- = *p++ | 0x8000; +else + *q-- = *p++; +#endif +/* skip over guard word */ +++p; +/* move the significand */ +#ifdef MIEEE +for( i=0; i<4; i++ ) + *q++ = *p++; +#else +#ifdef INFINITY +if (eiisinf (a)) + { + /* Intel long double infinity. */ + *q-- = 0x8000; + *q-- = 0; + *q-- = 0; + *q = 0; + return; + } +#endif +for( i=0; i<4; i++ ) + *q-- = *p++; +#endif +} + + +/* +; e type to IEEE double precision +; double d; +; unsigned short x[NE]; +; etoe53( x, &d ); +*/ + +#ifdef DEC + +void etoe53( x, e ) +unsigned short *x, *e; +{ +etodec( x, e ); /* see etodec.c */ +} + +static void toe53( x, y ) +unsigned short *x, *y; +{ +todec( x, y ); +} + +#else + +void etoe53( x, e ) +unsigned short *x, *e; +{ +unsigned short xi[NI]; +long exp; +int rndsav; + +#ifdef NANS +if( eisnan(x) ) + { + enan( e, 53 ); + return; + } +#endif +emovi( x, xi ); +exp = (long )xi[E] - (EXONE - 0x3ff); /* adjust exponent for offsets */ +#ifdef INFINITY +if( eisinf(x) ) + goto nonorm; +#endif +/* round off to nearest or even */ +rndsav = rndprc; +rndprc = 53; +emdnorm( xi, 0, 0, exp, 64 ); +rndprc = rndsav; +nonorm: +toe53( xi, e ); +} + + +static void toe53( x, y ) +unsigned short *x, *y; +{ +unsigned short i; +unsigned short *p; + + +#ifdef NANS +if( eiisnan(x) ) + { + enan( y, 53 ); + return; + } +#endif +p = &x[0]; +#ifdef IBMPC +y += 3; +#endif +*y = 0; /* output high order */ +if( *p++ ) + *y = 0x8000; /* output sign bit */ + +i = *p++; +if( i >= (unsigned int )2047 ) + { /* Saturate at largest number less than infinity. */ +#ifdef INFINITY + *y |= 0x7ff0; +#ifdef IBMPC + *(--y) = 0; + *(--y) = 0; + *(--y) = 0; +#endif +#ifdef MIEEE + ++y; + *y++ = 0; + *y++ = 0; + *y++ = 0; +#endif +#else + *y |= (unsigned short )0x7fef; +#ifdef IBMPC + *(--y) = 0xffff; + *(--y) = 0xffff; + *(--y) = 0xffff; +#endif +#ifdef MIEEE + ++y; + *y++ = 0xffff; + *y++ = 0xffff; + *y++ = 0xffff; +#endif +#endif + return; + } +if( i == 0 ) + { + (void )eshift( x, 4 ); + } +else + { + i <<= 4; + (void )eshift( x, 5 ); + } +i |= *p++ & (unsigned short )0x0f; /* *p = xi[M] */ +*y |= (unsigned short )i; /* high order output already has sign bit set */ +#ifdef IBMPC +*(--y) = *p++; +*(--y) = *p++; +*(--y) = *p; +#endif +#ifdef MIEEE +++y; +*y++ = *p++; +*y++ = *p++; +*y++ = *p++; +#endif +} + +#endif /* not DEC */ + + + +/* +; e type to IEEE single precision +; float d; +; unsigned short x[N+2]; +; xtod( x, &d ); +*/ +void etoe24( x, e ) +unsigned short *x, *e; +{ +long exp; +unsigned short xi[NI]; +int rndsav; + +#ifdef NANS +if( eisnan(x) ) + { + enan( e, 24 ); + return; + } +#endif +emovi( x, xi ); +exp = (long )xi[E] - (EXONE - 0177); /* adjust exponent for offsets */ +#ifdef INFINITY +if( eisinf(x) ) + goto nonorm; +#endif +/* round off to nearest or even */ +rndsav = rndprc; +rndprc = 24; +emdnorm( xi, 0, 0, exp, 64 ); +rndprc = rndsav; +nonorm: +toe24( xi, e ); +} + +static void toe24( x, y ) +unsigned short *x, *y; +{ +unsigned short i; +unsigned short *p; + +#ifdef NANS +if( eiisnan(x) ) + { + enan( y, 24 ); + return; + } +#endif +p = &x[0]; +#ifdef IBMPC +y += 1; +#endif +#ifdef DEC +y += 1; +#endif +*y = 0; /* output high order */ +if( *p++ ) + *y = 0x8000; /* output sign bit */ + +i = *p++; +if( i >= 255 ) + { /* Saturate at largest number less than infinity. */ +#ifdef INFINITY + *y |= (unsigned short )0x7f80; +#ifdef IBMPC + *(--y) = 0; +#endif +#ifdef DEC + *(--y) = 0; +#endif +#ifdef MIEEE + ++y; + *y = 0; +#endif +#else + *y |= (unsigned short )0x7f7f; +#ifdef IBMPC + *(--y) = 0xffff; +#endif +#ifdef DEC + *(--y) = 0xffff; +#endif +#ifdef MIEEE + ++y; + *y = 0xffff; +#endif +#endif + return; + } +if( i == 0 ) + { + (void )eshift( x, 7 ); + } +else + { + i <<= 7; + (void )eshift( x, 8 ); + } +i |= *p++ & (unsigned short )0x7f; /* *p = xi[M] */ +*y |= i; /* high order output already has sign bit set */ +#ifdef IBMPC +*(--y) = *p; +#endif +#ifdef DEC +*(--y) = *p; +#endif +#ifdef MIEEE +++y; +*y = *p; +#endif +} + + +/* Compare two e type numbers. + * + * unsigned short a[NE], b[NE]; + * ecmp( a, b ); + * + * returns +1 if a > b + * 0 if a == b + * -1 if a < b + * -2 if either a or b is a NaN. + */ +int ecmp( a, b ) +unsigned short *a, *b; +{ +unsigned short ai[NI], bi[NI]; +register unsigned short *p, *q; +register int i; +int msign; + +#ifdef NANS +if (eisnan (a) || eisnan (b)) + return( -2 ); +#endif +emovi( a, ai ); +p = ai; +emovi( b, bi ); +q = bi; + +if( *p != *q ) + { /* the signs are different */ +/* -0 equals + 0 */ + for( i=1; i<NI-1; i++ ) + { + if( ai[i] != 0 ) + goto nzro; + if( bi[i] != 0 ) + goto nzro; + } + return(0); +nzro: + if( *p == 0 ) + return( 1 ); + else + return( -1 ); + } +/* both are the same sign */ +if( *p == 0 ) + msign = 1; +else + msign = -1; +i = NI-1; +do + { + if( *p++ != *q++ ) + { + goto diff; + } + } +while( --i > 0 ); + +return(0); /* equality */ + + + +diff: + +if( *(--p) > *(--q) ) + return( msign ); /* p is bigger */ +else + return( -msign ); /* p is littler */ +} + + + + +/* Find nearest integer to x = floor( x + 0.5 ) + * + * unsigned short x[NE], y[NE] + * eround( x, y ); + */ +void eround( x, y ) +unsigned short *x, *y; +{ + +eadd( ehalf, x, y ); +efloor( y, y ); +} + + + + +/* +; convert long (32-bit) integer to e type +; +; long l; +; unsigned short x[NE]; +; ltoe( &l, x ); +; note &l is the memory address of l +*/ +void ltoe( lp, y ) +long *lp; /* lp is the memory address of a long integer */ +unsigned short *y; /* y is the address of a short */ +{ +unsigned short yi[NI]; +unsigned long ll; +int k; + +ecleaz( yi ); +if( *lp < 0 ) + { + ll = (unsigned long )( -(*lp) ); /* make it positive */ + yi[0] = 0xffff; /* put correct sign in the e type number */ + } +else + { + ll = (unsigned long )( *lp ); + } +/* move the long integer to yi significand area */ +if( sizeof(long) == 8 ) + { + yi[M] = (unsigned short) (ll >> (LONGBITS - 16)); + yi[M + 1] = (unsigned short) (ll >> (LONGBITS - 32)); + yi[M + 2] = (unsigned short) (ll >> 16); + yi[M + 3] = (unsigned short) ll; + yi[E] = EXONE + 47; /* exponent if normalize shift count were 0 */ + } +else + { + yi[M] = (unsigned short )(ll >> 16); + yi[M+1] = (unsigned short )ll; + yi[E] = EXONE + 15; /* exponent if normalize shift count were 0 */ + } +if( (k = enormlz( yi )) > NBITS ) /* normalize the significand */ + ecleaz( yi ); /* it was zero */ +else + yi[E] -= (unsigned short )k; /* subtract shift count from exponent */ +emovo( yi, y ); /* output the answer */ +} + +/* +; convert unsigned long (32-bit) integer to e type +; +; unsigned long l; +; unsigned short x[NE]; +; ltox( &l, x ); +; note &l is the memory address of l +*/ +void ultoe( lp, y ) +unsigned long *lp; /* lp is the memory address of a long integer */ +unsigned short *y; /* y is the address of a short */ +{ +unsigned short yi[NI]; +unsigned long ll; +int k; + +ecleaz( yi ); +ll = *lp; + +/* move the long integer to ayi significand area */ +if( sizeof(long) == 8 ) + { + yi[M] = (unsigned short) (ll >> (LONGBITS - 16)); + yi[M + 1] = (unsigned short) (ll >> (LONGBITS - 32)); + yi[M + 2] = (unsigned short) (ll >> 16); + yi[M + 3] = (unsigned short) ll; + yi[E] = EXONE + 47; /* exponent if normalize shift count were 0 */ + } +else + { + yi[M] = (unsigned short )(ll >> 16); + yi[M+1] = (unsigned short )ll; + yi[E] = EXONE + 15; /* exponent if normalize shift count were 0 */ + } +if( (k = enormlz( yi )) > NBITS ) /* normalize the significand */ + ecleaz( yi ); /* it was zero */ +else + yi[E] -= (unsigned short )k; /* subtract shift count from exponent */ +emovo( yi, y ); /* output the answer */ +} + + +/* +; Find long integer and fractional parts + +; long i; +; unsigned short x[NE], frac[NE]; +; xifrac( x, &i, frac ); + + The integer output has the sign of the input. The fraction is + the positive fractional part of abs(x). +*/ +void eifrac( x, i, frac ) +unsigned short *x; +long *i; +unsigned short *frac; +{ +unsigned short xi[NI]; +int j, k; +unsigned long ll; + +emovi( x, xi ); +k = (int )xi[E] - (EXONE - 1); +if( k <= 0 ) + { +/* if exponent <= 0, integer = 0 and real output is fraction */ + *i = 0L; + emovo( xi, frac ); + return; + } +if( k > (8 * sizeof(long) - 1) ) + { +/* +; long integer overflow: output large integer +; and correct fraction +*/ + j = 8 * sizeof(long) - 1; + if( xi[0] ) + *i = (long) ((unsigned long) 1) << j; + else + *i = (long) (((unsigned long) (~(0L))) >> 1); + (void )eshift( xi, k ); + } +if( k > 16 ) + { +/* + Shift more than 16 bits: shift up k-16 mod 16 + then shift by 16's. +*/ + j = k - ((k >> 4) << 4); + eshift (xi, j); + ll = xi[M]; + k -= j; + do + { + eshup6 (xi); + ll = (ll << 16) | xi[M]; + } + while ((k -= 16) > 0); + *i = ll; + if (xi[0]) + *i = -(*i); + } +else + { +/* shift not more than 16 bits */ + eshift( xi, k ); + *i = (long )xi[M] & 0xffff; + if( xi[0] ) + *i = -(*i); + } +xi[0] = 0; +xi[E] = EXONE - 1; +xi[M] = 0; +if( (k = enormlz( xi )) > NBITS ) + ecleaz( xi ); +else + xi[E] -= (unsigned short )k; + +emovo( xi, frac ); +} + + +/* +; Find unsigned long integer and fractional parts + +; unsigned long i; +; unsigned short x[NE], frac[NE]; +; xifrac( x, &i, frac ); + + A negative e type input yields integer output = 0 + but correct fraction. +*/ +void euifrac( x, i, frac ) +unsigned short *x; +unsigned long *i; +unsigned short *frac; +{ +unsigned short xi[NI]; +int j, k; +unsigned long ll; + +emovi( x, xi ); +k = (int )xi[E] - (EXONE - 1); +if( k <= 0 ) + { +/* if exponent <= 0, integer = 0 and argument is fraction */ + *i = 0L; + emovo( xi, frac ); + return; + } +if( k > (8 * sizeof(long)) ) + { +/* +; long integer overflow: output large integer +; and correct fraction +*/ + *i = ~(0L); + (void )eshift( xi, k ); + } +else if( k > 16 ) + { +/* + Shift more than 16 bits: shift up k-16 mod 16 + then shift up by 16's. +*/ + j = k - ((k >> 4) << 4); + eshift (xi, j); + ll = xi[M]; + k -= j; + do + { + eshup6 (xi); + ll = (ll << 16) | xi[M]; + } + while ((k -= 16) > 0); + *i = ll; + } +else + { +/* shift not more than 16 bits */ + eshift( xi, k ); + *i = (long )xi[M] & 0xffff; + } + +if( xi[0] ) /* A negative value yields unsigned integer 0. */ + *i = 0L; + +xi[0] = 0; +xi[E] = EXONE - 1; +xi[M] = 0; +if( (k = enormlz( xi )) > NBITS ) + ecleaz( xi ); +else + xi[E] -= (unsigned short )k; + +emovo( xi, frac ); +} + + + +/* +; Shift significand +; +; Shifts significand area up or down by the number of bits +; given by the variable sc. +*/ +int eshift( x, sc ) +unsigned short *x; +int sc; +{ +unsigned short lost; +unsigned short *p; + +if( sc == 0 ) + return( 0 ); + +lost = 0; +p = x + NI-1; + +if( sc < 0 ) + { + sc = -sc; + while( sc >= 16 ) + { + lost |= *p; /* remember lost bits */ + eshdn6(x); + sc -= 16; + } + + while( sc >= 8 ) + { + lost |= *p & 0xff; + eshdn8(x); + sc -= 8; + } + + while( sc > 0 ) + { + lost |= *p & 1; + eshdn1(x); + sc -= 1; + } + } +else + { + while( sc >= 16 ) + { + eshup6(x); + sc -= 16; + } + + while( sc >= 8 ) + { + eshup8(x); + sc -= 8; + } + + while( sc > 0 ) + { + eshup1(x); + sc -= 1; + } + } +if( lost ) + lost = 1; +return( (int )lost ); +} + + + +/* +; normalize +; +; Shift normalizes the significand area pointed to by argument +; shift count (up = positive) is returned. +*/ +int enormlz(x) +unsigned short x[]; +{ +register unsigned short *p; +int sc; + +sc = 0; +p = &x[M]; +if( *p != 0 ) + goto normdn; +++p; +if( *p & 0x8000 ) + return( 0 ); /* already normalized */ +while( *p == 0 ) + { + eshup6(x); + sc += 16; +/* With guard word, there are NBITS+16 bits available. + * return true if all are zero. + */ + if( sc > NBITS ) + return( sc ); + } +/* see if high byte is zero */ +while( (*p & 0xff00) == 0 ) + { + eshup8(x); + sc += 8; + } +/* now shift 1 bit at a time */ +while( (*p & 0x8000) == 0) + { + eshup1(x); + sc += 1; + if( sc > (NBITS+16) ) + { + mtherr( "enormlz", UNDERFLOW ); + return( sc ); + } + } +return( sc ); + +/* Normalize by shifting down out of the high guard word + of the significand */ +normdn: + +if( *p & 0xff00 ) + { + eshdn8(x); + sc -= 8; + } +while( *p != 0 ) + { + eshdn1(x); + sc -= 1; + + if( sc < -NBITS ) + { + mtherr( "enormlz", OVERFLOW ); + return( sc ); + } + } +return( sc ); +} + + + + +/* Convert e type number to decimal format ASCII string. + * The constants are for 64 bit precision. + */ + +#define NTEN 12 +#define MAXP 4096 + +#if NE == 10 +static unsigned short etens[NTEN + 1][NE] = +{ + {0x6576, 0x4a92, 0x804a, 0x153f, + 0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,}, /* 10**4096 */ + {0x6a32, 0xce52, 0x329a, 0x28ce, + 0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,}, /* 10**2048 */ + {0x526c, 0x50ce, 0xf18b, 0x3d28, + 0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,}, + {0x9c66, 0x58f8, 0xbc50, 0x5c54, + 0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,}, + {0x851e, 0xeab7, 0x98fe, 0x901b, + 0xddbb, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,}, + {0x0235, 0x0137, 0x36b1, 0x336c, + 0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,}, + {0x50f8, 0x25fb, 0xc76b, 0x6b71, + 0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,}, + {0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,}, /* 10**1 */ +}; + +static unsigned short emtens[NTEN + 1][NE] = +{ + {0x2030, 0xcffc, 0xa1c3, 0x8123, + 0x2de3, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,}, /* 10**-4096 */ + {0x8264, 0xd2cb, 0xf2ea, 0x12d4, + 0x4925, 0x2de4, 0x3436, 0x534f, 0xceae, 0x256b,}, /* 10**-2048 */ + {0xf53f, 0xf698, 0x6bd3, 0x0158, + 0x87a6, 0xc0bd, 0xda57, 0x82a5, 0xa2a6, 0x32b5,}, + {0xe731, 0x04d4, 0xe3f2, 0xd332, + 0x7132, 0xd21c, 0xdb23, 0xee32, 0x9049, 0x395a,}, + {0xa23e, 0x5308, 0xfefb, 0x1155, + 0xfa91, 0x1939, 0x637a, 0x4325, 0xc031, 0x3cac,}, + {0xe26d, 0xdbde, 0xd05d, 0xb3f6, + 0xac7c, 0xe4a0, 0x64bc, 0x467c, 0xddd0, 0x3e55,}, + {0x2a20, 0x6224, 0x47b3, 0x98d7, + 0x3f23, 0xe9a5, 0xa539, 0xea27, 0xa87f, 0x3f2a,}, + {0x0b5b, 0x4af2, 0xa581, 0x18ed, + 0x67de, 0x94ba, 0x4539, 0x1ead, 0xcfb1, 0x3f94,}, + {0xbf71, 0xa9b3, 0x7989, 0xbe68, + 0x4c2e, 0xe15b, 0xc44d, 0x94be, 0xe695, 0x3fc9,}, + {0x3d4d, 0x7c3d, 0x36ba, 0x0d2b, + 0xfdc2, 0xcefc, 0x8461, 0x7711, 0xabcc, 0x3fe4,}, + {0xc155, 0xa4a8, 0x404e, 0x6113, + 0xd3c3, 0x652b, 0xe219, 0x1758, 0xd1b7, 0x3ff1,}, + {0xd70a, 0x70a3, 0x0a3d, 0xa3d7, + 0x3d70, 0xd70a, 0x70a3, 0x0a3d, 0xa3d7, 0x3ff8,}, + {0xcccd, 0xcccc, 0xcccc, 0xcccc, + 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,}, /* 10**-1 */ +}; +#else +static unsigned short etens[NTEN+1][NE] = { +{0xc94c,0x979a,0x8a20,0x5202,0xc460,0x7525,},/* 10**4096 */ +{0xa74d,0x5de4,0xc53d,0x3b5d,0x9e8b,0x5a92,},/* 10**2048 */ +{0x650d,0x0c17,0x8175,0x7586,0xc976,0x4d48,}, +{0xcc65,0x91c6,0xa60e,0xa0ae,0xe319,0x46a3,}, +{0xddbc,0xde8d,0x9df9,0xebfb,0xaa7e,0x4351,}, +{0xc66f,0x8cdf,0x80e9,0x47c9,0x93ba,0x41a8,}, +{0x3cbf,0xa6d5,0xffcf,0x1f49,0xc278,0x40d3,}, +{0xf020,0xb59d,0x2b70,0xada8,0x9dc5,0x4069,}, +{0x0000,0x0000,0x0400,0xc9bf,0x8e1b,0x4034,}, +{0x0000,0x0000,0x0000,0x2000,0xbebc,0x4019,}, +{0x0000,0x0000,0x0000,0x0000,0x9c40,0x400c,}, +{0x0000,0x0000,0x0000,0x0000,0xc800,0x4005,}, +{0x0000,0x0000,0x0000,0x0000,0xa000,0x4002,}, /* 10**1 */ +}; + +static unsigned short emtens[NTEN+1][NE] = { +{0x2de4,0x9fde,0xd2ce,0x04c8,0xa6dd,0x0ad8,}, /* 10**-4096 */ +{0x4925,0x2de4,0x3436,0x534f,0xceae,0x256b,}, /* 10**-2048 */ +{0x87a6,0xc0bd,0xda57,0x82a5,0xa2a6,0x32b5,}, +{0x7133,0xd21c,0xdb23,0xee32,0x9049,0x395a,}, +{0xfa91,0x1939,0x637a,0x4325,0xc031,0x3cac,}, +{0xac7d,0xe4a0,0x64bc,0x467c,0xddd0,0x3e55,}, +{0x3f24,0xe9a5,0xa539,0xea27,0xa87f,0x3f2a,}, +{0x67de,0x94ba,0x4539,0x1ead,0xcfb1,0x3f94,}, +{0x4c2f,0xe15b,0xc44d,0x94be,0xe695,0x3fc9,}, +{0xfdc2,0xcefc,0x8461,0x7711,0xabcc,0x3fe4,}, +{0xd3c3,0x652b,0xe219,0x1758,0xd1b7,0x3ff1,}, +{0x3d71,0xd70a,0x70a3,0x0a3d,0xa3d7,0x3ff8,}, +{0xcccd,0xcccc,0xcccc,0xcccc,0xcccc,0x3ffb,}, /* 10**-1 */ +}; +#endif + +void e24toasc( x, string, ndigs ) +unsigned short x[]; +char *string; +int ndigs; +{ +unsigned short w[NI]; + +e24toe( x, w ); +etoasc( w, string, ndigs ); +} + + +void e53toasc( x, string, ndigs ) +unsigned short x[]; +char *string; +int ndigs; +{ +unsigned short w[NI]; + +e53toe( x, w ); +etoasc( w, string, ndigs ); +} + + +void e64toasc( x, string, ndigs ) +unsigned short x[]; +char *string; +int ndigs; +{ +unsigned short w[NI]; + +e64toe( x, w ); +etoasc( w, string, ndigs ); +} + +void e113toasc (x, string, ndigs) +unsigned short x[]; +char *string; +int ndigs; +{ +unsigned short w[NI]; + +e113toe (x, w); +etoasc (w, string, ndigs); +} + + +void etoasc( x, string, ndigs ) +unsigned short x[]; +char *string; +int ndigs; +{ +long digit; +unsigned short y[NI], t[NI], u[NI], w[NI]; +unsigned short *p, *r, *ten; +unsigned short sign; +int i, j, k, expon, rndsav; +char *s, *ss; +unsigned short m; + +rndsav = rndprc; +#ifdef NANS +if( eisnan(x) ) + { + sprintf( string, " NaN " ); + goto bxit; + } +#endif +rndprc = NBITS; /* set to full precision */ +emov( x, y ); /* retain external format */ +if( y[NE-1] & 0x8000 ) + { + sign = 0xffff; + y[NE-1] &= 0x7fff; + } +else + { + sign = 0; + } +expon = 0; +ten = &etens[NTEN][0]; +emov( eone, t ); +/* Test for zero exponent */ +if( y[NE-1] == 0 ) + { + for( k=0; k<NE-1; k++ ) + { + if( y[k] != 0 ) + goto tnzro; /* denormalized number */ + } + goto isone; /* legal all zeros */ + } +tnzro: + +/* Test for infinity. + */ +if( y[NE-1] == 0x7fff ) + { + if( sign ) + sprintf( string, " -Infinity " ); + else + sprintf( string, " Infinity " ); + goto bxit; + } + +/* Test for exponent nonzero but significand denormalized. + * This is an error condition. + */ +if( (y[NE-1] != 0) && ((y[NE-2] & 0x8000) == 0) ) + { + mtherr( "etoasc", DOMAIN ); + sprintf( string, "NaN" ); + goto bxit; + } + +/* Compare to 1.0 */ +i = ecmp( eone, y ); +if( i == 0 ) + goto isone; + +if( i < 0 ) + { /* Number is greater than 1 */ +/* Convert significand to an integer and strip trailing decimal zeros. */ + emov( y, u ); + u[NE-1] = EXONE + NBITS - 1; + + p = &etens[NTEN-4][0]; + m = 16; +do + { + ediv( p, u, t ); + efloor( t, w ); + for( j=0; j<NE-1; j++ ) + { + if( t[j] != w[j] ) + goto noint; + } + emov( t, u ); + expon += (int )m; +noint: + p += NE; + m >>= 1; + } +while( m != 0 ); + +/* Rescale from integer significand */ + u[NE-1] += y[NE-1] - (unsigned int )(EXONE + NBITS - 1); + emov( u, y ); +/* Find power of 10 */ + emov( eone, t ); + m = MAXP; + p = &etens[0][0]; + while( ecmp( ten, u ) <= 0 ) + { + if( ecmp( p, u ) <= 0 ) + { + ediv( p, u, u ); + emul( p, t, t ); + expon += (int )m; + } + m >>= 1; + if( m == 0 ) + break; + p += NE; + } + } +else + { /* Number is less than 1.0 */ +/* Pad significand with trailing decimal zeros. */ + if( y[NE-1] == 0 ) + { + while( (y[NE-2] & 0x8000) == 0 ) + { + emul( ten, y, y ); + expon -= 1; + } + } + else + { + emovi( y, w ); + for( i=0; i<NDEC+1; i++ ) + { + if( (w[NI-1] & 0x7) != 0 ) + break; +/* multiply by 10 */ + emovz( w, u ); + eshdn1( u ); + eshdn1( u ); + eaddm( w, u ); + u[1] += 3; + while( u[2] != 0 ) + { + eshdn1(u); + u[1] += 1; + } + if( u[NI-1] != 0 ) + break; + if( eone[NE-1] <= u[1] ) + break; + emovz( u, w ); + expon -= 1; + } + emovo( w, y ); + } + k = -MAXP; + p = &emtens[0][0]; + r = &etens[0][0]; + emov( y, w ); + emov( eone, t ); + while( ecmp( eone, w ) > 0 ) + { + if( ecmp( p, w ) >= 0 ) + { + emul( r, w, w ); + emul( r, t, t ); + expon += k; + } + k /= 2; + if( k == 0 ) + break; + p += NE; + r += NE; + } + ediv( t, eone, t ); + } +isone: +/* Find the first (leading) digit. */ +emovi( t, w ); +emovz( w, t ); +emovi( y, w ); +emovz( w, y ); +eiremain( t, y ); +digit = equot[NI-1]; +while( (digit == 0) && (ecmp(y,ezero) != 0) ) + { + eshup1( y ); + emovz( y, u ); + eshup1( u ); + eshup1( u ); + eaddm( u, y ); + eiremain( t, y ); + digit = equot[NI-1]; + expon -= 1; + } +s = string; +if( sign ) + *s++ = '-'; +else + *s++ = ' '; +/* Examine number of digits requested by caller. */ +if( ndigs < 0 ) + ndigs = 0; +if( ndigs > NDEC ) + ndigs = NDEC; +if( digit == 10 ) + { + *s++ = '1'; + *s++ = '.'; + if( ndigs > 0 ) + { + *s++ = '0'; + ndigs -= 1; + } + expon += 1; + } +else + { + *s++ = (char )digit + '0'; + *s++ = '.'; + } +/* Generate digits after the decimal point. */ +for( k=0; k<=ndigs; k++ ) + { +/* multiply current number by 10, without normalizing */ + eshup1( y ); + emovz( y, u ); + eshup1( u ); + eshup1( u ); + eaddm( u, y ); + eiremain( t, y ); + *s++ = (char )equot[NI-1] + '0'; + } +digit = equot[NI-1]; +--s; +ss = s; +/* round off the ASCII string */ +if( digit > 4 ) + { +/* Test for critical rounding case in ASCII output. */ + if( digit == 5 ) + { + emovo( y, t ); + if( ecmp(t,ezero) != 0 ) + goto roun; /* round to nearest */ + if( (*(s-1) & 1) == 0 ) + goto doexp; /* round to even */ + } +/* Round up and propagate carry-outs */ +roun: + --s; + k = *s & 0x7f; +/* Carry out to most significant digit? */ + if( k == '.' ) + { + --s; + k = *s; + k += 1; + *s = (char )k; +/* Most significant digit carries to 10? */ + if( k > '9' ) + { + expon += 1; + *s = '1'; + } + goto doexp; + } +/* Round up and carry out from less significant digits */ + k += 1; + *s = (char )k; + if( k > '9' ) + { + *s = '0'; + goto roun; + } + } +doexp: +/* +if( expon >= 0 ) + sprintf( ss, "e+%d", expon ); +else + sprintf( ss, "e%d", expon ); +*/ + sprintf( ss, "E%d", expon ); +bxit: +rndprc = rndsav; +} + + + + +/* +; ASCTOQ +; ASCTOQ.MAC LATEST REV: 11 JAN 84 +; SLM, 3 JAN 78 +; +; Convert ASCII string to quadruple precision floating point +; +; Numeric input is free field decimal number +; with max of 15 digits with or without +; decimal point entered as ASCII from teletype. +; Entering E after the number followed by a second +; number causes the second number to be interpreted +; as a power of 10 to be multiplied by the first number +; (i.e., "scientific" notation). +; +; Usage: +; asctoq( string, q ); +*/ + +/* ASCII to single */ +void asctoe24( s, y ) +char *s; +unsigned short *y; +{ +asctoeg( s, y, 24 ); +} + + +/* ASCII to double */ +void asctoe53( s, y ) +char *s; +unsigned short *y; +{ +#ifdef DEC +asctoeg( s, y, 56 ); +#else +asctoeg( s, y, 53 ); +#endif +} + + +/* ASCII to long double */ +void asctoe64( s, y ) +char *s; +unsigned short *y; +{ +asctoeg( s, y, 64 ); +} + +/* ASCII to 128-bit long double */ +void asctoe113 (s, y) +char *s; +unsigned short *y; +{ +asctoeg( s, y, 113 ); +} + +/* ASCII to super double */ +void asctoe( s, y ) +char *s; +unsigned short *y; +{ +asctoeg( s, y, NBITS ); +} + +/* Space to make a copy of the input string: */ +static char lstr[82] = {0}; + +void asctoeg( ss, y, oprec ) +char *ss; +unsigned short *y; +int oprec; +{ +unsigned short yy[NI], xt[NI], tt[NI]; +int esign, decflg, sgnflg, nexp, exp, prec, lost; +int k, trail, c, rndsav; +long lexp; +unsigned short nsign, *p; +char *sp, *s; + +/* Copy the input string. */ +s = ss; +while( *s == ' ' ) /* skip leading spaces */ + ++s; +sp = lstr; +for( k=0; k<79; k++ ) + { + if( (*sp++ = *s++) == '\0' ) + break; + } +*sp = '\0'; +s = lstr; + +rndsav = rndprc; +rndprc = NBITS; /* Set to full precision */ +lost = 0; +nsign = 0; +decflg = 0; +sgnflg = 0; +nexp = 0; +exp = 0; +prec = 0; +ecleaz( yy ); +trail = 0; + +nxtcom: +k = *s - '0'; +if( (k >= 0) && (k <= 9) ) + { +/* Ignore leading zeros */ + if( (prec == 0) && (decflg == 0) && (k == 0) ) + goto donchr; +/* Identify and strip trailing zeros after the decimal point. */ + if( (trail == 0) && (decflg != 0) ) + { + sp = s; + while( (*sp >= '0') && (*sp <= '9') ) + ++sp; +/* Check for syntax error */ + c = *sp & 0x7f; + if( (c != 'e') && (c != 'E') && (c != '\0') + && (c != '\n') && (c != '\r') && (c != ' ') + && (c != ',') ) + goto error; + --sp; + while( *sp == '0' ) + *sp-- = 'z'; + trail = 1; + if( *s == 'z' ) + goto donchr; + } +/* If enough digits were given to more than fill up the yy register, + * continuing until overflow into the high guard word yy[2] + * guarantees that there will be a roundoff bit at the top + * of the low guard word after normalization. + */ + if( yy[2] == 0 ) + { + if( decflg ) + nexp += 1; /* count digits after decimal point */ + eshup1( yy ); /* multiply current number by 10 */ + emovz( yy, xt ); + eshup1( xt ); + eshup1( xt ); + eaddm( xt, yy ); + ecleaz( xt ); + xt[NI-2] = (unsigned short )k; + eaddm( xt, yy ); + } + else + { + /* Mark any lost non-zero digit. */ + lost |= k; + /* Count lost digits before the decimal point. */ + if (decflg == 0) + nexp -= 1; + } + prec += 1; + goto donchr; + } + +switch( *s ) + { + case 'z': + break; + case 'E': + case 'e': + goto expnt; + case '.': /* decimal point */ + if( decflg ) + goto error; + ++decflg; + break; + case '-': + nsign = 0xffff; + if( sgnflg ) + goto error; + ++sgnflg; + break; + case '+': + if( sgnflg ) + goto error; + ++sgnflg; + break; + case ',': + case ' ': + case '\0': + case '\n': + case '\r': + goto daldone; + case 'i': + case 'I': + goto infinite; + default: + error: +#ifdef NANS + enan( yy, NI*16 ); +#else + mtherr( "asctoe", DOMAIN ); + ecleaz(yy); +#endif + goto aexit; + } +donchr: +++s; +goto nxtcom; + +/* Exponent interpretation */ +expnt: + +esign = 1; +exp = 0; +++s; +/* check for + or - */ +if( *s == '-' ) + { + esign = -1; + ++s; + } +if( *s == '+' ) + ++s; +while( (*s >= '0') && (*s <= '9') ) + { + exp *= 10; + exp += *s++ - '0'; + if (exp > 4977) + { + if (esign < 0) + goto zero; + else + goto infinite; + } + } +if( esign < 0 ) + exp = -exp; +if( exp > 4932 ) + { +infinite: + ecleaz(yy); + yy[E] = 0x7fff; /* infinity */ + goto aexit; + } +if( exp < -4977 ) + { +zero: + ecleaz(yy); + goto aexit; + } + +daldone: +nexp = exp - nexp; +/* Pad trailing zeros to minimize power of 10, per IEEE spec. */ +while( (nexp > 0) && (yy[2] == 0) ) + { + emovz( yy, xt ); + eshup1( xt ); + eshup1( xt ); + eaddm( yy, xt ); + eshup1( xt ); + if( xt[2] != 0 ) + break; + nexp -= 1; + emovz( xt, yy ); + } +if( (k = enormlz(yy)) > NBITS ) + { + ecleaz(yy); + goto aexit; + } +lexp = (EXONE - 1 + NBITS) - k; +emdnorm( yy, lost, 0, lexp, 64 ); +/* convert to external format */ + + +/* Multiply by 10**nexp. If precision is 64 bits, + * the maximum relative error incurred in forming 10**n + * for 0 <= n <= 324 is 8.2e-20, at 10**180. + * For 0 <= n <= 999, the peak relative error is 1.4e-19 at 10**947. + * For 0 >= n >= -999, it is -1.55e-19 at 10**-435. + */ +lexp = yy[E]; +if( nexp == 0 ) + { + k = 0; + goto expdon; + } +esign = 1; +if( nexp < 0 ) + { + nexp = -nexp; + esign = -1; + if( nexp > 4096 ) + { /* Punt. Can't handle this without 2 divides. */ + emovi( etens[0], tt ); + lexp -= tt[E]; + k = edivm( tt, yy ); + lexp += EXONE; + nexp -= 4096; + } + } +p = &etens[NTEN][0]; +emov( eone, xt ); +exp = 1; +do + { + if( exp & nexp ) + emul( p, xt, xt ); + p -= NE; + exp = exp + exp; + } +while( exp <= MAXP ); + +emovi( xt, tt ); +if( esign < 0 ) + { + lexp -= tt[E]; + k = edivm( tt, yy ); + lexp += EXONE; + } +else + { + lexp += tt[E]; + k = emulm( tt, yy ); + lexp -= EXONE - 1; + } + +expdon: + +/* Round and convert directly to the destination type */ +if( oprec == 53 ) + lexp -= EXONE - 0x3ff; +else if( oprec == 24 ) + lexp -= EXONE - 0177; +#ifdef DEC +else if( oprec == 56 ) + lexp -= EXONE - 0201; +#endif +rndprc = oprec; +emdnorm( yy, k, 0, lexp, 64 ); + +aexit: + +rndprc = rndsav; +yy[0] = nsign; +switch( oprec ) + { +#ifdef DEC + case 56: + todec( yy, y ); /* see etodec.c */ + break; +#endif + case 53: + toe53( yy, y ); + break; + case 24: + toe24( yy, y ); + break; + case 64: + toe64( yy, y ); + break; + case 113: + toe113( yy, y ); + break; + case NBITS: + emovo( yy, y ); + break; + } +} + + + +/* y = largest integer not greater than x + * (truncated toward minus infinity) + * + * unsigned short x[NE], y[NE] + * + * efloor( x, y ); + */ +static unsigned short bmask[] = { +0xffff, +0xfffe, +0xfffc, +0xfff8, +0xfff0, +0xffe0, +0xffc0, +0xff80, +0xff00, +0xfe00, +0xfc00, +0xf800, +0xf000, +0xe000, +0xc000, +0x8000, +0x0000, +}; + +void efloor( x, y ) +unsigned short x[], y[]; +{ +register unsigned short *p; +int e, expon, i; +unsigned short f[NE]; + +emov( x, f ); /* leave in external format */ +expon = (int )f[NE-1]; +e = (expon & 0x7fff) - (EXONE - 1); +if( e <= 0 ) + { + eclear(y); + goto isitneg; + } +/* number of bits to clear out */ +e = NBITS - e; +emov( f, y ); +if( e <= 0 ) + return; + +p = &y[0]; +while( e >= 16 ) + { + *p++ = 0; + e -= 16; + } +/* clear the remaining bits */ +*p &= bmask[e]; +/* truncate negatives toward minus infinity */ +isitneg: + +if( (unsigned short )expon & (unsigned short )0x8000 ) + { + for( i=0; i<NE-1; i++ ) + { + if( f[i] != y[i] ) + { + esub( eone, y, y ); + break; + } + } + } +} + + +/* unsigned short x[], s[]; + * long *exp; + * + * efrexp( x, exp, s ); + * + * Returns s and exp such that s * 2**exp = x and .5 <= s < 1. + * For example, 1.1 = 0.55 * 2**1 + * Handles denormalized numbers properly using long integer exp. + */ +void efrexp( x, exp, s ) +unsigned short x[]; +long *exp; +unsigned short s[]; +{ +unsigned short xi[NI]; +long li; + +emovi( x, xi ); +li = (long )((short )xi[1]); + +if( li == 0 ) + { + li -= enormlz( xi ); + } +xi[1] = 0x3ffe; +emovo( xi, s ); +*exp = li - 0x3ffe; +} + + + +/* unsigned short x[], y[]; + * long pwr2; + * + * eldexp( x, pwr2, y ); + * + * Returns y = x * 2**pwr2. + */ +void eldexp( x, pwr2, y ) +unsigned short x[]; +long pwr2; +unsigned short y[]; +{ +unsigned short xi[NI]; +long li; +int i; + +emovi( x, xi ); +li = xi[1]; +li += pwr2; +i = 0; +emdnorm( xi, i, i, li, 64 ); +emovo( xi, y ); +} + + +/* c = remainder after dividing b by a + * Least significant integer quotient bits left in equot[]. + */ +void eremain( a, b, c ) +unsigned short a[], b[], c[]; +{ +unsigned short den[NI], num[NI]; + +#ifdef NANS +if( eisinf(b) || (ecmp(a,ezero) == 0) || eisnan(a) || eisnan(b)) + { + enan( c, NBITS ); + return; + } +#endif +if( ecmp(a,ezero) == 0 ) + { + mtherr( "eremain", SING ); + eclear( c ); + return; + } +emovi( a, den ); +emovi( b, num ); +eiremain( den, num ); +/* Sign of remainder = sign of quotient */ +if( a[0] == b[0] ) + num[0] = 0; +else + num[0] = 0xffff; +emovo( num, c ); +} + + +void eiremain( den, num ) +unsigned short den[], num[]; +{ +long ld, ln; +unsigned short j; + +ld = den[E]; +ld -= enormlz( den ); +ln = num[E]; +ln -= enormlz( num ); +ecleaz( equot ); +while( ln >= ld ) + { + if( ecmpm(den,num) <= 0 ) + { + esubm(den, num); + j = 1; + } + else + { + j = 0; + } + eshup1(equot); + equot[NI-1] |= j; + eshup1(num); + ln -= 1; + } +emdnorm( num, 0, 0, ln, 0 ); +} + +/* NaN bit patterns + */ +#ifdef MIEEE +unsigned short nan113[8] = { + 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; +unsigned short nan64[6] = {0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff}; +unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff}; +unsigned short nan24[2] = {0x7fff, 0xffff}; +#endif + +#ifdef IBMPC +unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0xc000, 0xffff}; +unsigned short nan64[6] = {0, 0, 0, 0xc000, 0xffff, 0}; +unsigned short nan53[4] = {0, 0, 0, 0xfff8}; +unsigned short nan24[2] = {0, 0xffc0}; +#endif + + +void enan (nan, size) +unsigned short *nan; +int size; +{ +int i, n; +unsigned short *p; + +switch( size ) + { +#ifndef DEC + case 113: + n = 8; + p = nan113; + break; + + case 64: + n = 6; + p = nan64; + break; + + case 53: + n = 4; + p = nan53; + break; + + case 24: + n = 2; + p = nan24; + break; + + case NBITS: + for( i=0; i<NE-2; i++ ) + *nan++ = 0; + *nan++ = 0xc000; + *nan++ = 0x7fff; + return; + + case NI*16: + *nan++ = 0; + *nan++ = 0x7fff; + *nan++ = 0; + *nan++ = 0xc000; + for( i=4; i<NI; i++ ) + *nan++ = 0; + return; +#endif + default: + mtherr( "enan", DOMAIN ); + return; + } +for (i=0; i < n; i++) + *nan++ = *p++; +} + + + +/* Longhand square root. */ + +static int esqinited = 0; +static unsigned short sqrndbit[NI]; + +void esqrt( x, y ) +short *x, *y; +{ +unsigned short temp[NI], num[NI], sq[NI], xx[NI]; +int i, j, k, n, nlups; +long m, exp; + +if( esqinited == 0 ) + { + ecleaz( sqrndbit ); + sqrndbit[NI-2] = 1; + esqinited = 1; + } +/* Check for arg <= 0 */ +i = ecmp( x, ezero ); +if( i <= 0 ) + { +#ifdef NANS + if (i == -2) + { + enan (y, NBITS); + return; + } +#endif + eclear(y); + if( i < 0 ) + mtherr( "esqrt", DOMAIN ); + return; + } + +#ifdef INFINITY +if( eisinf(x) ) + { + eclear(y); + einfin(y); + return; + } +#endif +/* Bring in the arg and renormalize if it is denormal. */ +emovi( x, xx ); +m = (long )xx[1]; /* local long word exponent */ +if( m == 0 ) + m -= enormlz( xx ); + +/* Divide exponent by 2 */ +m -= 0x3ffe; +exp = (unsigned short )( (m / 2) + 0x3ffe ); + +/* Adjust if exponent odd */ +if( (m & 1) != 0 ) + { + if( m > 0 ) + exp += 1; + eshdn1( xx ); + } + +ecleaz( sq ); +ecleaz( num ); +n = 8; /* get 8 bits of result per inner loop */ +nlups = rndprc; +j = 0; + +while( nlups > 0 ) + { +/* bring in next word of arg */ + if( j < NE ) + num[NI-1] = xx[j+3]; +/* Do additional bit on last outer loop, for roundoff. */ + if( nlups <= 8 ) + n = nlups + 1; + for( i=0; i<n; i++ ) + { +/* Next 2 bits of arg */ + eshup1( num ); + eshup1( num ); +/* Shift up answer */ + eshup1( sq ); +/* Make trial divisor */ + for( k=0; k<NI; k++ ) + temp[k] = sq[k]; + eshup1( temp ); + eaddm( sqrndbit, temp ); +/* Subtract and insert answer bit if it goes in */ + if( ecmpm( temp, num ) <= 0 ) + { + esubm( temp, num ); + sq[NI-2] |= 1; + } + } + nlups -= n; + j += 1; + } + +/* Adjust for extra, roundoff loop done. */ +exp += (NBITS - 1) - rndprc; + +/* Sticky bit = 1 if the remainder is nonzero. */ +k = 0; +for( i=3; i<NI; i++ ) + k |= (int )num[i]; + +/* Renormalize and round off. */ +emdnorm( sq, k, 0, exp, 64 ); +emovo( sq, y ); +} diff --git a/regress/lib/libc/cephes/ieetst.c b/regress/lib/libc/cephes/ieetst.c new file mode 100644 index 00000000000..fdce864f401 --- /dev/null +++ b/regress/lib/libc/cephes/ieetst.c @@ -0,0 +1,875 @@ +/* $OpenBSD: ieetst.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* Floating point to ASCII input and output string test program. + * + * Numbers in the native machine data structure are converted + * to e type, then to and from decimal ASCII strings. Native + * printf() and scanf() functions are also used to produce + * and read strings. The resulting e type binary values + * are compared, with diagnostic printouts of any discrepancies. + * + * Steve Moshier, 16 Dec 88 + * last revision: 16 May 92 + */ + +#include <stdio.h> + +#include "mconf.h" +#include "ehead.h" + +/* Include tests of 80-bit long double precision: */ +#define LDOUBLE 0 +/* Abort subtest after getting this many errors: */ +#define MAXERR 5 +/* Number of random arguments to try (set as large as you have + * patience for): */ +#define NRAND 100 +/* Perform internal consistency test: */ +#define CHKINTERNAL 0 + +static unsigned short fullp[NE], rounded[NE]; +float prec24, sprec24, ssprec24; +double prec53, sprec53, ssprec53; +#if LDOUBLE +long double prec64, sprec64, ssprec64; +#endif + +static unsigned short rprint[NE], rscan[NE]; +static unsigned short q1[NE], q2[NE], q5[NE]; +static unsigned short e1[NE], e2[NE], e3[NE]; +static double d1, d2; +static int errprint = 0; +static int errscan = 0; +static int identerr = 0; +static int errtot = 0; +static int count = 0; +static char str0[80], str1[80], str2[80], str3[80]; +static unsigned short eten[NE], maxm[NE]; + +int m, n, k2, mprec, SPREC; + +char *Ten = "10.0"; +char tformat[10]; +char *format24 = "%.8e"; +#ifdef DEC +char *format53 = "%.17e"; +#else +char *format53 = "%.16e"; +#endif +char *fformat24 = "%e"; +char *fformat53 = "%le"; +char *pct = "%"; +char *quo = "\042"; +#if LDOUBLE +char *format64 = "%.20Le"; +char *fformat64 = "%Le"; +#endif +char *format; +char *fformat; +char *toomany = "Too many errors; aborting this test.\n"; + +static int mnrflag; +static int etrflag; +void chkit(), printerr(), mnrand(), etrand(), shownoncrit(); +void chkid(), pvec(); + +main() +{ +int i, iprec, retval = 0; + +printf( "Steve Moshier's printf/scanf tester, version 0.2.\n\n" ); +#ifdef DEC + /* DEC PDP-11/VAX single precision not yet implemented */ +for( iprec = 1; iprec<2; iprec++ ) +#else +for( iprec = 0; iprec<3; iprec++ ) +/*for( iprec = 2; iprec<3; iprec++ )*/ +#endif + { + errscan = 0; + identerr = 0; + errprint = 0; + eclear( rprint ); + eclear( rscan ); + +switch( iprec ) + { + case 0: + SPREC = 8; /* # digits after the decimal point */ + mprec = 24; /* # bits in the significand */ + m = 9; /* max # decimal digits for correct rounding */ + n = 13; /* max power of ten for correct rounding */ + k2 = -125; /* underflow beyond 2^-k2 */ + format = format24; /* printf format string */ + fformat = fformat24; /* scanf format string */ + mnrflag = 1; /* sets interval for random numbers */ + etrflag = 1; + printf( "Testing FLOAT precision.\n" ); + break; + + case 1: +#ifdef DEC + SPREC = 17; + mprec = 56; + m = 17; + n = 27; + k2 = -125; + format = format53; + fformat = fformat53; + mnrflag = 2; + etrflag = 1; + printf( "Testing DEC DOUBLE precision.\n" ); + break; +#else + SPREC = 16; + mprec = 53; + m = 17; + n = 27; + k2 = -1021; + format = format53; + fformat = fformat53; + mnrflag = 2; + etrflag = 2; + printf( "Testing DOUBLE precision.\n" ); + break; +#endif + case 2: +#if LDOUBLE + SPREC = 20; + mprec = 64; + m = 20; + n = 34; + k2 = -16382; + format = format64; + fformat = fformat64; + mnrflag = 3; + etrflag = 3; + printf( "Testing LONG DOUBLE precision.\n" ); + break; +#else + goto nodenorm; +#endif + } + + asctoe( Ten, eten ); +/* 10^m - 1 */ + d2 = m; + e53toe( &d2, e1 ); + epow( eten, e1, maxm ); + esub( eone, maxm, maxm ); + +/* test 1 */ + printf( "1. Checking 10^n - 1 for n = %d to %d.\n", -m, m ); + emov( eone, q5 ); + for( count=0; count<=m; count++ ) + { + esub( eone, q5, fullp ); + chkit( 1 ); + ediv( q5, eone, q2 ); + esub( eone, q2, fullp ); + chkit( 1 ); + emul( eten, q5, q5 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end1; + } + } +end1: + printerr(); + + +/* test 2 */ + printf( "2. Checking powers of 10 from 10^-%d to 10^%d.\n", n, n ); + emov( eone, q5 ); + for( count=0; count<=n; count++ ) + { + emov( q5, fullp ); + chkit( 2 ); + ediv( q5, eone, fullp ); + chkit( 2 ); + emul( eten, q5, q5 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end2; + } + } +end2: + printerr(); + +/* test 3 */ + printf( "3. Checking (10^%d-1)*10^n from n = -%d to %d.\n", m, n, n ); + emov( eone, q5 ); + for( count= -n; count<=n; count++ ) + { + emul( maxm, q5, fullp ); + chkit( 3 ); + emov( q5, fullp ); + ediv( fullp, eone, fullp ); + emul( maxm, fullp, fullp ); + chkit( 3 ); + emul( eten, q5, q5 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end3; + } + } +end3: + printerr(); + + + +/* test 4 */ + printf( "4. Checking powers of 2 from 2^-24 to 2^+56.\n" ); + d1 = -24.0; + e53toe( &d1, q1 ); + epow( etwo, q1, q5 ); + + for( count = -24; count <= 56; count++ ) + { + emov( q5, fullp ); + chkit( 4 ); + emul( etwo, q5, q5 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end4; + } + } +end4: + printerr(); + + +/* test 5 */ + printf( "5. Checking 2^n - 1 for n = 0 to %d.\n", mprec ); + emov( eone, q5 ); + for( count=0; count<=mprec; count++ ) + { + esub( eone, q5, fullp ); + chkit( 5 ); + emul( etwo, q5, q5 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end5; + } + } +end5: + printerr(); + +/* test 6 */ + printf( "6. Checking 2^n + 1 for n = 0 to %d.\n", mprec ); + emov( eone, q5 ); + for( count=0; count<=mprec; count++ ) + { + eadd( eone, q5, fullp ); + chkit( 6 ); + emul( etwo, q5, q5 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end6; + } + } +end6: + printerr(); + +/* test 7 */ + printf( + "7. Checking %d values M * 10^N with random integer M and N,\n", + NRAND ); + printf(" 1 <= M <= 10^%d - 1 and -%d <= N <= +%d.\n", m, n, n ); + for( i=0; i<NRAND; i++ ) + { + mnrand( fullp ); + chkit( 7 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end7; + } + } +end7: + printerr(); + +/* test 8 */ + printf("8. Checking critical rounding cases.\n" ); + for( i=0; i<20; i++ ) + { + mnrand( fullp ); + eabs( fullp ); + if( ecmp( fullp, eone ) < 0 ) + ediv( fullp, eone, fullp ); + efloor( fullp, fullp ); + eadd( ehalf, fullp, fullp ); + chkit( 8 ); + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto end8; + } + } +end8: + printerr(); + + + +/* test 9 */ + printf("9. Testing on %d random non-denormal values.\n", NRAND ); + for( i=0; i<NRAND; i++ ) + { + etrand( fullp ); + chkit( 9 ); + } + printerr(); + shownoncrit(); + +/* test 10 */ +#if 0 + printf( + "Do you want to check denormal numbers in this precision ? (y/n) " ); + gets( str0 ); + if( str0[0] != 'y' ) + goto nodenorm; +#endif + + printf( "10. Checking denormal numbers.\n" ); + +/* Form 2^-starting power */ + d1 = k2; + e53toe( &d1, q1 ); + epow( etwo, q1, e1 ); + +/* Find 2^-mprec less than starting power */ + d1 = -mprec + 4; + e53toe( &d1, q1 ); + epow( etwo, q1, e3 ); + emul( e1, e3, e3 ); + emov( e3, e2 ); + ediv( etwo, e2, e2 ); + + while( ecmp(e1,e2) != 0 ) + { + eadd( e1, e2, fullp ); + switch( mprec ) + { +#if LDOUBLE + case 64: + etoe64( e1, &sprec64 ); + e64toe( &sprec64, q1 ); + etoe64( fullp, &prec64 ); + e64toe( &prec64, q2 ); + break; +#endif +#ifdef DEC + case 56: +#endif + case 53: + etoe53( e1, &sprec53 ); + e53toe( &sprec53, q1 ); + etoe53( fullp, &prec53 ); + e53toe( &prec53, q2 ); + break; + + case 24: + etoe24( e1, &sprec24 ); + e24toe( &sprec24, q1 ); + etoe24( fullp, &prec24 ); + e24toe( &prec24, q2 ); + break; + } + if( ecmp( q2, ezero ) == 0 ) + goto maxden; + chkit(10); + if( ecmp(q1,q2) == 0 ) + { + ediv( etwo, e1, e1 ); + emov( e3, e2 ); + } + if( errtot >= MAXERR ) + { + printf( "%s", toomany ); + goto maxden; + } + ediv( etwo, e2, e2 ); + } +maxden: + printerr(); +nodenorm: + printf( "\n" ); + retval |= errscan | identerr | errprint; + } /* loop on precision */ +printf( "End of test.\n" ); +return (retval); +} + +#if CHKINTERNAL +long double xprec64; +double xprec53; +float xprec24; + +/* Check binary -> printf -> scanf -> binary identity + * of internal routines + */ +void chkinternal( ref, tst, string ) +unsigned short ref[], tst[]; +char *string; +{ + +if( ecmp(ref,tst) != 0 ) + { + printf( "internal identity compare error!\n" ); + chkid( ref, tst, string ); + } +} +#endif + + +/* Check binary -> printf -> scanf -> binary identity + */ +void chkid( print, scan, string ) +unsigned short print[], scan[]; +char *string; +{ +/* Test printf-scanf identity */ +if( ecmp( print, scan ) != 0 ) + { + pvec( print, NE ); + printf( " ->printf-> %s ->scanf->\n", string ); + pvec( scan, NE ); + printf( " is not an identity.\n" ); + ++identerr; + } +} + + +/* Check scanf result + */ +void chkscan( ref, tst, string ) +unsigned short ref[], tst[]; +char *string; +{ +/* Test scanf() */ +if( ecmp( ref, tst ) != 0 ) + { + printf( "scanf(%s) -> ", string ); + pvec( tst, NE ); + printf( "\n should be " ); + pvec( ref, NE ); + printf( ".\n" ); + ++errscan; + ++errtot; + } +} + + +/* Test printf() result + */ +void chkprint( ref, tst, string ) +unsigned short ref[], tst[]; +char *string; +{ +if( ecmp(ref, tst) != 0 ) + { + printf( "printf( "); + pvec( ref, NE ); + printf( ") -> %s\n", string ); + printf( " = " ); + pvec( tst, NE ); + printf( ".\n" ); + ++errprint; + ++errtot; + } +} + + +/* Print array of n 16-bit shorts + */ +void pvec( x, n ) +unsigned short x[]; +int n; +{ +int i; + +for( i=0; i<n; i++ ) + { + printf( "%04x ", x[i] ); + } +} + +/* Measure worst case printf rounding error + */ +void cmpprint( ref, tst ) +unsigned short ref[], tst[]; +{ +unsigned short e[NE]; + +if( ecmp( ref, ezero ) != 0 ) + { + esub( ref, tst, e ); + ediv( ref, e, e ); + eabs( e ); + if( ecmp( e, rprint ) > 0 ) + emov( e, rprint ); + } +} + +/* Measure worst case scanf rounding error + */ +void cmpscan( ref, tst ) +unsigned short ref[], tst[]; +{ +unsigned short er[NE]; + +if( ecmp( ref, ezero ) != 0 ) + { + esub( ref, tst, er ); + ediv( ref, er, er ); + eabs( er ); + if( ecmp( er, rscan ) > 0 ) + emov( er, rscan ); + if( ecmp( er, ehalf ) > 0 ) + { + etoasc( tst, str1, 21 ); + printf( "Bad error: scanf(%s) = %s !\n", str0, str1 ); + } + } +} + +/* Check rounded-down decimal string output of printf + */ +void cmptrunc( ref, tst ) +unsigned short ref[], tst[]; +{ +if( ecmp( ref, tst ) != 0 ) + { + printf( "printf(%s%s%s, %s) -> %s\n", quo, tformat, quo, str1, str2 ); + printf( "should be %s .\n", str3 ); + errprint += 1; + } +} + + +void shownoncrit() +{ + +etoasc( rprint, str0, 3 ); +printf( "Maximum relative printf error found = %s .\n", str0 ); +etoasc( rscan, str0, 3 ); +printf( "Maximum relative scanf error found = %s .\n", str0 ); +} + + + +/* Produce arguments and call comparison subroutines. + */ +void chkit( testno ) +int testno; +{ +unsigned short t[NE], u[NE], v[NE]; +int j; + +switch( mprec ) + { +#if LDOUBLE + case 64: + etoe64( fullp, &prec64 ); + e64toe( &prec64, rounded ); +#if CHKINTERNAL + e64toasc( &prec64, str1, SPREC ); + asctoe64( str1, &xprec64 ); + e64toe( &xprec64, t ); + chkinternal( rounded, t, str1 ); +#endif +/* check printf and scanf */ + sprintf( str2, format, prec64 ); + sscanf( str2, fformat, &sprec64 ); + e64toe( &sprec64, u ); + chkid( rounded, u, str2 ); + asctoe64( str2, &ssprec64 ); + e64toe( &ssprec64, v ); + chkscan( v, u, str2 ); + chkprint( rounded, v, str2 ); + if( testno < 8 ) + break; +/* rounding error measurement */ + etoasc( fullp, str0, 24 ); + etoe64( fullp, &ssprec64 ); + e64toe( &ssprec64, u ); + sprintf( str2, format, ssprec64 ); + asctoe( str2, t ); + cmpprint( u, t ); + sscanf( str0, fformat, &sprec64 ); + e64toe( &sprec64, t ); + cmpscan( fullp, t ); + if( testno < 8 ) + break; +/* strings rounded to less than maximum precision */ + e64toasc( &ssprec64, str1, 24 ); + for( j=SPREC-1; j>0; j-- ) + { + e64toasc( &ssprec64, str3, j ); + asctoe( str3, v ); + sprintf( tformat, "%s.%dLe", pct, j ); + sprintf( str2, tformat, ssprec64 ); + asctoe( str2, t ); + cmptrunc( v, t ); + } + break; +#endif +#ifdef DEC + case 56: +#endif + case 53: + etoe53( fullp, &prec53 ); + e53toe( &prec53, rounded ); +#if CHKINTERNAL + e53toasc( &prec53, str1, SPREC ); + asctoe53( str1, &xprec53 ); + e53toe( &xprec53, t ); + chkinternal( rounded, t, str1 ); +#endif + sprintf( str2, format, prec53 ); + sscanf( str2, fformat, &sprec53 ); + e53toe( &sprec53, u ); + chkid( rounded, u, str2 ); + asctoe53( str2, &ssprec53 ); + e53toe( &ssprec53, v ); + chkscan( v, u, str2 ); + chkprint( rounded, v, str2 ); + if( testno < 8 ) + break; +/* rounding error measurement */ + etoasc( fullp, str0, 24 ); + etoe53( fullp, &ssprec53 ); + e53toe( &ssprec53, u ); + sprintf( str2, format, ssprec53 ); + asctoe( str2, t ); + cmpprint( u, t ); + sscanf( str0, fformat, &sprec53 ); + e53toe( &sprec53, t ); + cmpscan( fullp, t ); + if( testno < 8 ) + break; + e53toasc( &ssprec53, str1, 24 ); + for( j=SPREC-1; j>0; j-- ) + { + e53toasc( &ssprec53, str3, j ); + asctoe( str3, v ); + sprintf( tformat, "%s.%de", pct, j ); + sprintf( str2, tformat, ssprec53 ); + asctoe( str2, t ); + cmptrunc( v, t ); + } + break; + + case 24: + etoe24( fullp, &prec24 ); + e24toe( &prec24, rounded ); +#if CHKINTERNAL + e24toasc( &prec24, str1, SPREC ); + asctoe24( str1, &xprec24 ); + e24toe( &xprec24, t ); + chkinternal( rounded, t, str1 ); +#endif + sprintf( str2, format, prec24 ); + sscanf( str2, fformat, &sprec24 ); + e24toe( &sprec24, u ); + chkid( rounded, u, str2 ); + asctoe24( str2, &ssprec24 ); + e24toe( &ssprec24, v ); + chkscan( v, u, str2 ); + chkprint( rounded, v, str2 ); + if( testno < 8 ) + break; +/* rounding error measurement */ + etoasc( fullp, str0, 24 ); + etoe24( fullp, &ssprec24 ); + e24toe( &ssprec24, u ); + sprintf( str2, format, ssprec24 ); + asctoe( str2, t ); + cmpprint( u, t ); + sscanf( str0, fformat, &sprec24 ); + e24toe( &sprec24, t ); + cmpscan( fullp, t ); +/* + if( testno < 8 ) + break; +*/ + e24toasc( &ssprec24, str1, 24 ); + for( j=SPREC-1; j>0; j-- ) + { + e24toasc( &ssprec24, str3, j ); + asctoe( str3, v ); + sprintf( tformat, "%s.%de", pct, j ); + sprintf( str2, tformat, ssprec24 ); + asctoe( str2, t ); + cmptrunc( v, t ); + } + break; + } +} + + +void printerr() +{ +if( (errscan == 0) && (identerr == 0) && (errprint == 0) ) + printf( "No errors found.\n" ); +else + { + printf( "%d binary -> decimal errors found.\n", errprint ); + printf( "%d decimal -> binary errors found.\n", errscan ); + } +errscan = 0; /* reset for next test */ +identerr = 0; +errprint = 0; +errtot = 0; +} + + +/* Random number generator + * in the range M * 10^N, where 1 <= M <= 10^17 - 1 + * and -27 <= N <= +27. Test values of M are logarithmically distributed + * random integers; test values of N are uniformly distributed random integers. + */ + +static char *fwidth = "1.036163291797320557783096e1"; /* log(sqrt(10^9-1)) */ +static char *dwidth = "1.957197329044938830915E1"; /* log(sqrt(10^17-1)) */ +static char *ldwidth = "2.302585092994045684017491e1"; /* log(sqrt(10^20-1)) */ + +static char *a13 = "13.0"; +static char *a27 = "27.0"; +static char *a34 = "34.0"; +static char *a10m13 = "1.0e-13"; +static unsigned short LOW[ NE ], WIDTH[NE], e27[NE], e10m13[NE]; + + +void mnrand( erand ) +unsigned short erand[]; +{ +unsigned short ea[NE], em[NE], en[NE], ex[NE]; +double x, a; + +if( mnrflag ) + { + if( mnrflag == 3 ) + { + asctoe( ldwidth, WIDTH ); + asctoe( a34, e27 ); + } + if( mnrflag == 2 ) + { + asctoe( dwidth, WIDTH ); + asctoe( a27, e27 ); + } + if( mnrflag == 1 ) + { + asctoe( fwidth, WIDTH ); + asctoe( a13, e27 ); + } + asctoe( a10m13, e10m13 ); + mnrflag = 0; + } +drand( &x ); +e53toe( &x, ex ); /* x = WIDTH * ( x - 1.0 ) + LOW; */ +esub( eone, ex, ex ); +emul( WIDTH, ex, ex ); +eexp( ex, ex ); /* x = exp(x); */ + +drand( &a ); +e53toe( &a, ea ); +emul( ea, ex, ea ); /* a = 1.0e-13 * x * a; */ +emul( e10m13, ea, ea ); +eabs( ea ); +eadd( ea, ex, ex ); /* add fuzz */ +emul( ex, ex, ex ); /* square it, to get range to 10^17 - 1 */ +efloor( ex, em ); /* this is M */ + +/* Random power of 10 */ +drand( &a ); +e53toe( &a, ex ); +esub( eone, ex, ex ); /* y3 = 54.0 * ( y3 - 1.0 ) + 0.5; */ +emul( e27, ex, ex ); +eadd( ex, ex, ex ); +eadd( ehalf, ex, ex ); +efloor( ex, ex ); /* y3 = floor( y3 ) - 27.0; */ +esub( e27, ex, en ); /* this is N */ +epow( eten, en, ex ); +emul( ex, em, erand ); +} + +/* -ln 2^16382 */ +char *ldemin = "-1.1355137111933024058873097E4"; +char *ldewid = "2.2710274223866048117746193E4"; +/* -ln 2^1022 */ +char *demin = "-7.0839641853226410622441123E2"; +char *dewid = "1.4167928370645282124488225E3"; +/* -ln 2^125 */ +char *femin = "-8.6643397569993163677154015E1"; +char *fewid = "1.7328679513998632735430803E2"; + +void etrand( erand ) +unsigned short erand[]; +{ +unsigned short ea[NE], ex[NE]; +double x, a; + +if( etrflag ) + { + if( etrflag == 3 ) + { + asctoe( ldemin, LOW ); + asctoe( ldewid, WIDTH ); + asctoe( a34, e27 ); + } + if( etrflag == 2 ) + { + asctoe( demin, LOW ); + asctoe( dewid, WIDTH ); + asctoe( a27, e27 ); + } + if( etrflag == 1 ) + { + asctoe( femin, LOW ); + asctoe( fewid, WIDTH ); + asctoe( a13, e27 ); + } + asctoe( a10m13, e10m13 ); + etrflag = 0; + } +drand( &x ); +e53toe( &x, ex ); /* x = WIDTH * ( x - 1.0 ) + LOW; */ +esub( eone, ex, ex ); +emul( WIDTH, ex, ex ); +eadd( LOW, ex, ex ); +eexp( ex, ex ); /* x = exp(x); */ + +/* add fuzz + */ +drand( &a ); +e53toe( &a, ea ); +emul( ea, ex, ea ); /* a = 1.0e-13 * x * a; */ +emul( e10m13, ea, ea ); +if( ecmp( ex, ezero ) > 0 ) + eneg( ea ); +eadd( ea, ex, erand ); +} + diff --git a/regress/lib/libc/cephes/mconf.h b/regress/lib/libc/cephes/mconf.h new file mode 100644 index 00000000000..a92bd3ab643 --- /dev/null +++ b/regress/lib/libc/cephes/mconf.h @@ -0,0 +1,187 @@ +/* $OpenBSD: mconf.h,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* mconf.h + * + * Common include file for math routines + * + * + * + * SYNOPSIS: + * + * #include "mconf.h" + * + * + * + * DESCRIPTION: + * + * This file contains definitions for error codes that are + * passed to the common error handling routine mtherr() + * (which see). + * + * The file also includes a conditional assembly definition + * for the type of computer arithmetic (IEEE, DEC, Motorola + * IEEE, or UNKnown). + * + * For Digital Equipment PDP-11 and VAX computers, certain + * IBM systems, and others that use numbers with a 56-bit + * significand, the symbol DEC should be defined. In this + * mode, most floating point constants are given as arrays + * of octal integers to eliminate decimal to binary conversion + * errors that might be introduced by the compiler. + * + * For little-endian computers, such as IBM PC, that follow the + * IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE + * Std 754-1985), the symbol IBMPC should be defined. These + * numbers have 53-bit significands. In this mode, constants + * are provided as arrays of hexadecimal 16 bit integers. + * + * Big-endian IEEE format is denoted MIEEE. On some RISC + * systems such as Sun SPARC, double precision constants + * must be stored on 8-byte address boundaries. Since integer + * arrays may be aligned differently, the MIEEE configuration + * may fail on such machines. + * + * To accommodate other types of computer arithmetic, all + * constants are also provided in a normal decimal radix + * which one can hope are correctly converted to a suitable + * format by the available C language compiler. To invoke + * this mode, define the symbol UNK. + * + * An important difference among these modes is a predefined + * set of machine arithmetic constants for each. The numbers + * MACHEP (the machine roundoff error), MAXNUM (largest number + * represented), and several other parameters are preset by + * the configuration symbol. Check the file const.c to + * ensure that these values are correct for your computer. + * + * Configurations NANS, INFINITIES, MINUSZERO, and DENORMAL + * may fail on many systems. Verify that they are supposed + * to work on your computer. + */ + +#include <sys/types.h> +#include <sys/endian.h> + +/* Constant definitions for math error conditions + */ + +#define DOMAIN 1 /* argument domain error */ +#define SING 2 /* argument singularity */ +#define OVERFLOW 3 /* overflow range error */ +#define UNDERFLOW 4 /* underflow range error */ +#define TLOSS 5 /* total loss of precision */ +#define PLOSS 6 /* partial loss of precision */ + +#define EDOM 33 +#define ERANGE 34 + +/* Complex numeral. */ +typedef struct + { + double r; + double i; + } cmplx; + +/* Long double complex numeral. */ +typedef struct + { + double r; + double i; + } cmplxl; + +/* Type of computer arithmetic */ + +/* PDP-11, Pro350, VAX: + */ +#ifdef __vax__ +#define DEC 1 +#endif /* __vax__ */ + +/* Intel IEEE, low order words come first: + */ +/* #define IBMPC 1 */ + +/* Motorola IEEE, high order words come first + * (Sun 680x0 workstation): + */ +/* #define MIEEE 1 */ + +/* UNKnown arithmetic, invokes coefficients given in + * normal decimal format. Beware of range boundary + * problems (MACHEP, MAXLOG, etc. in const.c) and + * roundoff problems in pow.c: + * (Sun SPARCstation) + */ +#ifndef __vax__ +#define UNK 1 +#endif /* !__vax__ */ + +/* If you define UNK, then be sure to set BIGENDIAN properly. */ +#if BYTE_ORDER == BIG_ENDIAN +#define BIGENDIAN 1 +#endif /* BYTE_ORDER == BIG_ENDIAN */ + +/* Define this `volatile' if your compiler thinks + * that floating point arithmetic obeys the associative + * and distributive laws. It will defeat some optimizations + * (but probably not enough of them). + * + * #define VOLATILE volatile + */ +#define VOLATILE + +/* For 12-byte long doubles on an i386, pad a 16-bit short 0 + * to the end of real constants initialized by integer arrays. + * + * #define XPD 0, + * + * Otherwise, the type is 10 bytes long and XPD should be + * defined blank (e.g., Microsoft C). + * + * #define XPD + */ +#define XPD 0, + +/* Define to support tiny denormal numbers, else undefine. */ +#ifndef __vax__ +#define DENORMAL 1 +#endif /* !__vax__ */ + +/* Define to ask for infinity support, else undefine. */ +#ifndef __vax__ +#define INFINITIES 1 +#endif /* !__vax__ */ + +/* Define to ask for support of numbers that are Not-a-Number, + else undefine. This may automatically define INFINITIES in some files. */ +#ifndef __vax__ +#define NANS 1 +#endif /* !__vax__ */ + +/* Define to distinguish between -0.0 and +0.0. */ +#define MINUSZERO 1 + +/* Define 1 for ANSI C atan2() function + See atan.c and clog.c. */ +#define ANSIC 1 + +int mtherr(); + +/* Variable for error reporting. See mtherr.c. */ +extern int merror; diff --git a/regress/lib/libc/cephes/mtherr.c b/regress/lib/libc/cephes/mtherr.c new file mode 100644 index 00000000000..9a47a198bd0 --- /dev/null +++ b/regress/lib/libc/cephes/mtherr.c @@ -0,0 +1,114 @@ +/* $OpenBSD: mtherr.c,v 1.1 2011/07/02 18:11:01 martynas Exp $ */ + +/* + * Copyright (c) 2008 Stephen L. Moshier <steve@moshier.net> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* mtherr.c + * + * Library common error handling routine + * + * + * + * SYNOPSIS: + * + * char *fctnam; + * int code; + * int mtherr(); + * + * mtherr( fctnam, code ); + * + * + * + * DESCRIPTION: + * + * This routine may be called to report one of the following + * error conditions (in the include file mconf.h). + * + * Mnemonic Value Significance + * + * DOMAIN 1 argument domain error + * SING 2 function singularity + * OVERFLOW 3 overflow range error + * UNDERFLOW 4 underflow range error + * TLOSS 5 total loss of precision + * PLOSS 6 partial loss of precision + * EDOM 33 Unix domain error code + * ERANGE 34 Unix range error code + * + * The default version of the file prints the function name, + * passed to it by the pointer fctnam, followed by the + * error condition. The display is directed to the standard + * output device. The routine then returns to the calling + * program. Users may wish to modify the program to abort by + * calling exit() under severe error conditions such as domain + * errors. + * + * Since all error conditions pass control to this function, + * the display may be easily changed, eliminated, or directed + * to an error logging device. + * + * SEE ALSO: + * + * mconf.h + * + */ + +#include <stdio.h> +#include "mconf.h" + +int merror = 0; + +/* Notice: the order of appearance of the following + * messages is bound to the error codes defined + * in mconf.h. + */ +static char *ermsg[7] = { +"unknown", /* error code 0 */ +"domain", /* error code 1 */ +"singularity", /* et seq. */ +"overflow", +"underflow", +"total loss of precision", +"partial loss of precision" +}; + + +int mtherr( name, code ) +char *name; +int code; +{ + +/* Display string passed by calling program, + * which is supposed to be the name of the + * function in which the error occurred: + */ +printf( "\n%s ", name ); + +/* Set global error message word */ +merror = code; + +/* Display error message defined + * by the code argument. + */ +if( (code <= 0) || (code >= 7) ) + code = 0; +printf( "%s error\n", ermsg[code] ); + +/* Return to calling + * program + */ +return( 0 ); +} |