-\r
- /* Extended precision arithmetic functions for long double I/O.\r
- * This program has been placed in the public domain.\r
- */\r
-\r
-#include <_ansi.h>\r
-#include <reent.h>\r
-#include <string.h>\r
-#include <stdlib.h>\r
-#include <alloca.h>\r
-#include "mprec.h"\r
-\r
-/* These are the externally visible entries. */\r
-/* linux name: long double _IO_strtold (char *, char **); */\r
-long double _strtold (char *, char **);\r
-char * _ldtoa_r (struct _reent *, long double, int, int, int *, int *, char **);\r
-#if 0\r
-void _IO_ldtostr(long double *, char *, int, int, char);\r
-#endif\r
-\r
- /* Number of 16 bit words in external x type format */\r
- #define NE 10\r
-\r
- /* Number of 16 bit words in internal format */\r
- #define NI (NE+3)\r
-\r
- /* Array offset to exponent */\r
- #define E 1\r
-\r
- /* Array offset to high guard word */\r
- #define M 2\r
-\r
- /* Number of bits of precision */\r
- #define NBITS ((NI-4)*16)\r
-\r
- /* Maximum number of decimal digits in ASCII conversion\r
- * = NBITS*log10(2)\r
- */\r
- #define NDEC (NBITS*8/27)\r
-\r
- /* The exponent of 1.0 */\r
- #define EXONE (0x3fff)\r
-\r
-/* Control structure for long doublue conversion including rounding precision values.\r
- * rndprc can be set to 80 (if NE=6), 64, 56, 53, or 24 bits.\r
- */\r
-typedef struct\r
-{\r
- int rlast;\r
- int rndprc;\r
- int rw;\r
- int re;\r
- int outexpon;\r
- unsigned short rmsk;\r
- unsigned short rmbit;\r
- unsigned short rebit;\r
- unsigned short rbit[NI];\r
- unsigned short equot[NI];\r
-} LDPARMS;\r
-\r
-static void esub(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp);\r
-static void emul(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp);\r
-static void ediv(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp);\r
-static int ecmp(short unsigned int *a, short unsigned int *b);\r
-static int enormlz(short unsigned int *x);\r
-static int eshift(short unsigned int *x, int sc);\r
-static void eshup1(register short unsigned int *x);\r
-static void eshup8(register short unsigned int *x);\r
-static void eshup6(register short unsigned int *x);\r
-static void eshdn1(register short unsigned int *x);\r
-static void eshdn8(register short unsigned int *x);\r
-static void eshdn6(register short unsigned int *x);\r
-static void eneg(short unsigned int *x);\r
-static void emov(register short unsigned int *a, register short unsigned int *b);\r
-static void eclear(register short unsigned int *x);\r
-static void einfin(register short unsigned int *x, register LDPARMS *ldp);\r
-static void efloor(short unsigned int *x, short unsigned int *y, LDPARMS *ldp);\r
-static void etoasc(short unsigned int *x, char *string, int ndigs, int outformat, LDPARMS *ldp);\r
-#if LDBL_MANT_DIG == 24\r
-static void e24toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);\r
-#elif LDBL_MANT_DIG == 53\r
-static void e53toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);\r
-#elif LDBL_MANT_DIG == 64\r
-static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);\r
-#else\r
-static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);\r
-#endif\r
-\r
-/* econst.c */\r
-/* e type constants used by high precision check routines */\r
-\r
-#if NE == 10\r
-/* 0.0 */\r
-static unsigned short ezero[NE] =\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,};\r
-\r
-/* 1.0E0 */\r
-static unsigned short eone[NE] =\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,};\r
-\r
-#else\r
-\r
-/* 0.0 */\r
-static unsigned short ezero[NE] = {\r
-0, 0000000,0000000,0000000,0000000,0000000,};\r
-/* 1.0E0 */\r
-static unsigned short eone[NE] = {\r
-0, 0000000,0000000,0000000,0100000,0x3fff,};\r
-\r
-#endif\r
-\r
-/* Debugging routine for displaying errors */\r
-#ifdef DEBUG\r
-/* Notice: the order of appearance of the following\r
- * messages is bound to the error codes defined\r
- * in mconf.h.\r
- */\r
-static char *ermsg[7] = {\r
-"unknown", /* error code 0 */\r
-"domain", /* error code 1 */\r
-"singularity", /* et seq. */\r
-"overflow",\r
-"underflow",\r
-"total loss of precision",\r
-"partial loss of precision"\r
-};\r
-#define mtherr(name, code) printf( "\n%s %s error\n", name, ermsg[code] );\r
-#else\r
-#define mtherr(name, code)\r
-#endif\r
-\r
-/* ieee.c\r
- *\r
- * Extended precision IEEE binary floating point arithmetic routines\r
- *\r
- * Numbers are stored in C language as arrays of 16-bit unsigned\r
- * short integers. The arguments of the routines are pointers to\r
- * the arrays.\r
- *\r
- *\r
- * External e type data structure, simulates Intel 8087 chip\r
- * temporary real format but possibly with a larger significand:\r
- *\r
- * NE-1 significand words (least significant word first,\r
- * most significant bit is normally set)\r
- * exponent (value = EXONE for 1.0,\r
- * top bit is the sign)\r
- *\r
- *\r
- * Internal data structure of a number (a "word" is 16 bits):\r
- *\r
- * ei[0] sign word (0 for positive, 0xffff for negative)\r
- * ei[1] biased exponent (value = EXONE for the number 1.0)\r
- * ei[2] high guard word (always zero after normalization)\r
- * ei[3]\r
- * to ei[NI-2] significand (NI-4 significand words,\r
- * most significant word first,\r
- * most significant bit is set)\r
- * ei[NI-1] low guard word (0x8000 bit is rounding place)\r
- *\r
- *\r
- *\r
- * Routines for external format numbers\r
- *\r
- * asctoe( string, e ) ASCII string to extended double e type\r
- * asctoe64( string, &d ) ASCII string to long double\r
- * asctoe53( string, &d ) ASCII string to double\r
- * asctoe24( string, &f ) ASCII string to single\r
- * asctoeg( string, e, prec, ldp ) ASCII string to specified precision\r
- * e24toe( &f, e, ldp ) IEEE single precision to e type\r
- * e53toe( &d, e, ldp ) IEEE double precision to e type\r
- * e64toe( &d, e, ldp ) IEEE long double precision to e type\r
- * e113toe( &d, e, ldp ) IEEE long double precision to e type\r
- * eabs(e) absolute value\r
- * eadd( a, b, c ) c = b + a\r
- * eclear(e) e = 0\r
- * ecmp (a, b) Returns 1 if a > b, 0 if a == b,\r
- * -1 if a < b, -2 if either a or b is a NaN.\r
- * ediv( a, b, c, ldp ) c = b / a\r
- * efloor( a, b, ldp ) truncate to integer, toward -infinity\r
- * efrexp( a, exp, s ) extract exponent and significand\r
- * eifrac( e, &l, frac ) e to long integer and e type fraction\r
- * euifrac( e, &l, frac ) e to unsigned long integer and e type fraction\r
- * einfin( e, ldp ) set e to infinity, leaving its sign alone\r
- * eldexp( a, n, b ) multiply by 2**n\r
- * emov( a, b ) b = a\r
- * emul( a, b, c, ldp ) c = b * a\r
- * eneg(e) e = -e\r
- * eround( a, b ) b = nearest integer value to a\r
- * esub( a, b, c, ldp ) c = b - a\r
- * e24toasc( &f, str, n ) single to ASCII string, n digits after decimal\r
- * e53toasc( &d, str, n ) double to ASCII string, n digits after decimal\r
- * e64toasc( &d, str, n ) long double to ASCII string\r
- * etoasc(e,str,n,fmt,ldp)e to ASCII string, n digits after decimal\r
- * etoe24( e, &f ) convert e type to IEEE single precision\r
- * etoe53( e, &d ) convert e type to IEEE double precision\r
- * etoe64( e, &d ) convert e type to IEEE long double precision\r
- * ltoe( &l, e ) long (32 bit) integer to e type\r
- * ultoe( &l, e ) unsigned long (32 bit) integer to e type\r
- * eisneg( e ) 1 if sign bit of e != 0, else 0\r
- * eisinf( e ) 1 if e has maximum exponent (non-IEEE)\r
- * or is infinite (IEEE)\r
- * eisnan( e ) 1 if e is a NaN\r
- * esqrt( a, b ) b = square root of a\r
- *\r
- *\r
- * Routines for internal format numbers\r
- *\r
- * eaddm( ai, bi ) add significands, bi = bi + ai\r
- * ecleaz(ei) ei = 0\r
- * ecleazs(ei) set ei = 0 but leave its sign alone\r
- * ecmpm( ai, bi ) compare significands, return 1, 0, or -1\r
- * edivm( ai, bi, ldp ) divide significands, bi = bi / ai\r
- * emdnorm(ai,l,s,exp,ldp) normalize and round off\r
- * emovi( a, ai ) convert external a to internal ai\r
- * emovo( ai, a, ldp ) convert internal ai to external a\r
- * emovz( ai, bi ) bi = ai, low guard word of bi = 0\r
- * emulm( ai, bi, ldp ) multiply significands, bi = bi * ai\r
- * enormlz(ei) left-justify the significand\r
- * eshdn1( ai ) shift significand and guards down 1 bit\r
- * eshdn8( ai ) shift down 8 bits\r
- * eshdn6( ai ) shift down 16 bits\r
- * eshift( ai, n ) shift ai n bits up (or down if n < 0)\r
- * eshup1( ai ) shift significand and guards up 1 bit\r
- * eshup8( ai ) shift up 8 bits\r
- * eshup6( ai ) shift up 16 bits\r
- * esubm( ai, bi ) subtract significands, bi = bi - ai\r
- *\r
- *\r
- * The result is always normalized and rounded to NI-4 word precision\r
- * after each arithmetic operation.\r
- *\r
- * Exception flags are NOT fully supported.\r
- *\r
- * Define INFINITY in mconf.h for support of infinity; otherwise a\r
- * saturation arithmetic is implemented.\r
- *\r
- * Define NANS for support of Not-a-Number items; otherwise the\r
- * arithmetic will never produce a NaN output, and might be confused\r
- * by a NaN input.\r
- * If NaN's are supported, the output of ecmp(a,b) is -2 if\r
- * either a or b is a NaN. This means asking if(ecmp(a,b) < 0)\r
- * may not be legitimate. Use if(ecmp(a,b) == -1) for less-than\r
- * if in doubt.\r
- * Signaling NaN's are NOT supported; they are treated the same\r
- * as quiet NaN's.\r
- *\r
- * Denormals are always supported here where appropriate (e.g., not\r
- * for conversion to DEC numbers).\r
- */\r
-\r
-/*\r
- * Revision history:\r
- *\r
- * 5 Jan 84 PDP-11 assembly language version\r
- * 6 Dec 86 C language version\r
- * 30 Aug 88 100 digit version, improved rounding\r
- * 15 May 92 80-bit long double support\r
- * 22 Nov 00 Revised to fit into newlib by Jeff Johnston <jjohnstn@redhat.com>\r
- *\r
- * Author: S. L. Moshier.\r
- *\r
- * Copyright (c) 1984,2000 S.L. Moshier\r
- *\r
- * Permission to use, copy, modify, and distribute this software for any\r
- * purpose without fee is hereby granted, provided that this entire notice\r
- * is included in all copies of any software which is or includes a copy\r
- * or modification of this software and in all copies of the supporting\r
- * documentation for such software.\r
- *\r
- * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED\r
- * WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION\r
- * OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS\r
- * SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.\r
- *\r
- */\r
-\r
-#include <stdio.h>\r
-/* #include "\usr\include\stdio.h" */\r
-/*#include "ehead.h"*/\r
-/*#include "mconf.h"*/\r
-/* mconf.h\r
- *\r
- * Common include file for math routines\r
- *\r
- *\r
- *\r
- * SYNOPSIS:\r
- *\r
- * #include "mconf.h"\r
- *\r
- *\r
- *\r
- * DESCRIPTION:\r
- *\r
- * This file contains definitions for error codes that are\r
- * passed to the common error handling routine mtherr()\r
- * (which see).\r
- *\r
- * The file also includes a conditional assembly definition\r
- * for the type of computer arithmetic (IEEE, DEC, Motorola\r
- * IEEE, or UNKnown).\r
- *\r
- * For Digital Equipment PDP-11 and VAX computers, certain\r
- * IBM systems, and others that use numbers with a 56-bit\r
- * significand, the symbol DEC should be defined. In this\r
- * mode, most floating point constants are given as arrays\r
- * of octal integers to eliminate decimal to binary conversion\r
- * errors that might be introduced by the compiler.\r
- *\r
- * For computers, such as IBM PC, that follow the IEEE \r
- * Standard for Binary Floating Point Arithmetic (ANSI/IEEE\r
- * Std 754-1985), the symbol IBMPC should be defined. These\r
- * numbers have 53-bit significands. In this mode, constants\r
- * are provided as arrays of hexadecimal 16 bit integers.\r
- *\r
- * To accommodate other types of computer arithmetic, all\r
- * constants are also provided in a normal decimal radix\r
- * which one can hope are correctly converted to a suitable\r
- * format by the available C language compiler. To invoke\r
- * this mode, the symbol UNK is defined.\r
- *\r
- * An important difference among these modes is a predefined\r
- * set of machine arithmetic constants for each. The numbers\r
- * MACHEP (the machine roundoff error), MAXNUM (largest number\r
- * represented), and several other parameters are preset by\r
- * the configuration symbol. Check the file const.c to\r
- * ensure that these values are correct for your computer.\r
- *\r
- * For ANSI C compatibility, define ANSIC equal to 1. Currently\r
- * this affects only the atan2() function and others that use it.\r
- */\r
-\r
-/* Constant definitions for math error conditions\r
- */\r
-\r
-#define DOMAIN 1 /* argument domain error */\r
-#define SING 2 /* argument singularity */\r
-#define OVERFLOW 3 /* overflow range error */\r
-#define UNDERFLOW 4 /* underflow range error */\r
-#define TLOSS 5 /* total loss of precision */\r
-#define PLOSS 6 /* partial loss of precision */\r
-\r
-#define EDOM 33\r
-#define ERANGE 34\r
-\r
-typedef struct\r
- {\r
- double r;\r
- double i;\r
- }cmplx;\r
-\r
-/* Type of computer arithmetic */\r
-\r
-#ifndef DEC\r
-#ifdef __IEEE_LITTLE_ENDIAN\r
-#define IBMPC 1\r
-#else /* !__IEEE_LITTLE_ENDIAN */\r
-#define MIEEE 1\r
-#endif /* !__IEEE_LITTLE_ENDIAN */\r
-#endif /* !DEC */\r
-\r
-/* Define 1 for ANSI C atan2() function\r
- * See atan.c and clog.c.\r
- */\r
-#define ANSIC 1\r
-\r
-/*define VOLATILE volatile*/\r
-#define VOLATILE \r
-\r
-#define NANS\r
-#define INFINITY\r
-\r
-/* NaN's require infinity support. */\r
-#ifdef NANS\r
-#ifndef INFINITY\r
-#define INFINITY\r
-#endif\r
-#endif\r
-\r
-/* This handles 64-bit long ints. */\r
-#define LONGBITS (8 * sizeof(long))\r
-\r
-\r
-static void eaddm(short unsigned int *x, short unsigned int *y);\r
-static void esubm(short unsigned int *x, short unsigned int *y);\r
-static void emdnorm(short unsigned int *s, int lost, int subflg, long int exp, int rcntrl, LDPARMS *ldp);\r
-static int asctoeg(char *ss, short unsigned int *y, int oprec, LDPARMS *ldp);\r
-static void enan(short unsigned int *nan, int size);\r
-#if LDBL_MANT_DIG == 24\r
-static void toe24(short unsigned int *x, short unsigned int *y);\r
-#elif LDBL_MANT_DIG == 53\r
-static void toe53(short unsigned int *x, short unsigned int *y);\r
-#elif LDBL_MANT_DIG == 64\r
-static void toe64(short unsigned int *a, short unsigned int *b);\r
-#else\r
-static void toe113(short unsigned int *a, short unsigned int *b);\r
-#endif\r
-static void eiremain(short unsigned int *den, short unsigned int *num, LDPARMS *ldp);\r
-static int ecmpm(register short unsigned int *a, register short unsigned int *b);\r
-static int edivm(short unsigned int *den, short unsigned int *num, LDPARMS *ldp);\r
-static int emulm(short unsigned int *a, short unsigned int *b, LDPARMS *ldp);\r
-static int eisneg(short unsigned int *x);\r
-static int eisinf(short unsigned int *x);\r
-static void emovi(short unsigned int *a, short unsigned int *b);\r
-static void emovo(short unsigned int *a, short unsigned int *b, LDPARMS *ldp);\r
-static void emovz(register short unsigned int *a, register short unsigned int *b);\r
-static void ecleaz(register short unsigned int *xi);\r
-static void eadd1(short unsigned int *a, short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp);\r
-static int eisnan(short unsigned int *x);\r
-static int eiisnan(short unsigned int *x);\r
-\r
-#ifdef DEC\r
-static void etodec(), todec(), dectoe();\r
-#endif\r
-\r
-/*\r
-; Clear out entire external format number.\r
-;\r
-; unsigned short x[];\r
-; eclear( x );\r
-*/\r
-\r
-static void eclear(register short unsigned int *x)\r
-{\r
-register int i;\r
-\r
-for( i=0; i<NE; i++ )\r
- *x++ = 0;\r
-}\r
-\r
-\r
-\r
-/* Move external format number from a to b.\r
- *\r
- * emov( a, b );\r
- */\r
-\r
-static void emov(register short unsigned int *a, register short unsigned int *b)\r
-{\r
-register int i;\r
-\r
-for( i=0; i<NE; i++ )\r
- *b++ = *a++;\r
-}\r
-\r
-\r
-/*\r
-; Negate external format number\r
-;\r
-; unsigned short x[NE];\r
-; eneg( x );\r
-*/\r
-\r
-static void eneg(short unsigned int *x)\r
-{\r
-\r
-#ifdef NANS\r
-if( eisnan(x) )\r
- return;\r
-#endif\r
-x[NE-1] ^= 0x8000; /* Toggle the sign bit */\r
-}\r
-\r
-\r
-\r
-/* Return 1 if external format number is negative,\r
- * else return zero.\r
- */\r
-static int eisneg(short unsigned int *x)\r
-{\r
-\r
-#ifdef NANS\r
-if( eisnan(x) )\r
- return( 0 );\r
-#endif\r
-if( x[NE-1] & 0x8000 )\r
- return( 1 );\r
-else\r
- return( 0 );\r
-}\r
-\r
-\r
-/* Return 1 if external format number has maximum possible exponent,\r
- * else return zero.\r
- */\r
-static int eisinf(short unsigned int *x)\r
-{\r
-\r
-if( (x[NE-1] & 0x7fff) == 0x7fff )\r
- {\r
-#ifdef NANS\r
- if( eisnan(x) )\r
- return( 0 );\r
-#endif\r
- return( 1 );\r
- }\r
-else\r
- return( 0 );\r
-}\r
-\r
-/* Check if e-type number is not a number.\r
- */\r
-static int eisnan(short unsigned int *x)\r
-{\r
-\r
-#ifdef NANS\r
-int i;\r
-/* NaN has maximum exponent */\r
-if( (x[NE-1] & 0x7fff) != 0x7fff )\r
- return (0);\r
-/* ... and non-zero significand field. */\r
-for( i=0; i<NE-1; i++ )\r
- {\r
- if( *x++ != 0 )\r
- return (1);\r
- }\r
-#endif\r
-return (0);\r
-}\r
-\r
-/*\r
-; Fill entire number, including exponent and significand, with\r
-; largest possible number. These programs implement a saturation\r
-; value that is an ordinary, legal number. A special value\r
-; "infinity" may also be implemented; this would require tests\r
-; for that value and implementation of special rules for arithmetic\r
-; operations involving inifinity.\r
-*/\r
-\r
-static void einfin(register short unsigned int *x, register LDPARMS *ldp)\r
-{\r
-register int i;\r
-\r
-#ifdef INFINITY\r
-for( i=0; i<NE-1; i++ )\r
- *x++ = 0;\r
-*x |= 32767;\r
-ldp = ldp;\r
-#else\r
-for( i=0; i<NE-1; i++ )\r
- *x++ = 0xffff;\r
-*x |= 32766;\r
-if( ldp->rndprc < NBITS )\r
- {\r
- if (ldp->rndprc == 113)\r
- {\r
- *(x - 9) = 0;\r
- *(x - 8) = 0;\r
- }\r
- if( ldp->rndprc == 64 )\r
- {\r
- *(x-5) = 0;\r
- }\r
- if( ldp->rndprc == 53 )\r
- {\r
- *(x-4) = 0xf800;\r
- }\r
- else\r
- {\r
- *(x-4) = 0;\r
- *(x-3) = 0;\r
- *(x-2) = 0xff00;\r
- }\r
- }\r
-#endif\r
-}\r
-\r
-/* Move in external format number,\r
- * converting it to internal format.\r
- */\r
-static void emovi(short unsigned int *a, short unsigned int *b)\r
-{\r
-register unsigned short *p, *q;\r
-int i;\r
-\r
-q = b;\r
-p = a + (NE-1); /* point to last word of external number */\r
-/* get the sign bit */\r
-if( *p & 0x8000 )\r
- *q++ = 0xffff;\r
-else\r
- *q++ = 0;\r
-/* get the exponent */\r
-*q = *p--;\r
-*q++ &= 0x7fff; /* delete the sign bit */\r
-#ifdef INFINITY\r
-if( (*(q-1) & 0x7fff) == 0x7fff )\r
- {\r
-#ifdef NANS\r
- if( eisnan(a) )\r
- {\r
- *q++ = 0;\r
- for( i=3; i<NI; i++ )\r
- *q++ = *p--;\r
- return;\r
- }\r
-#endif\r
- for( i=2; i<NI; i++ )\r
- *q++ = 0;\r
- return;\r
- }\r
-#endif\r
-/* clear high guard word */\r
-*q++ = 0;\r
-/* move in the significand */\r
-for( i=0; i<NE-1; i++ )\r
- *q++ = *p--;\r
-/* clear low guard word */\r
-*q = 0;\r
-}\r
-\r
-\r
-/* Move internal format number out,\r
- * converting it to external format.\r
- */\r
-static void emovo(short unsigned int *a, short unsigned int *b, LDPARMS *ldp)\r
-{\r
-register unsigned short *p, *q;\r
-unsigned short i;\r
-\r
-p = a;\r
-q = b + (NE-1); /* point to output exponent */\r
-/* combine sign and exponent */\r
-i = *p++;\r
-if( i )\r
- *q-- = *p++ | 0x8000;\r
-else\r
- *q-- = *p++;\r
-#ifdef INFINITY\r
-if( *(p-1) == 0x7fff )\r
- {\r
-#ifdef NANS\r
- if( eiisnan(a) )\r
- {\r
- enan( b, NBITS );\r
- return;\r
- }\r
-#endif\r
- einfin(b, ldp);\r
- return;\r
- }\r
-#endif\r
-/* skip over guard word */\r
-++p;\r
-/* move the significand */\r
-for( i=0; i<NE-1; i++ )\r
- *q-- = *p++;\r
-}\r
-\r
-\r
-/* Clear out internal format number.\r
- */\r
-\r
-static void ecleaz(register short unsigned int *xi)\r
-{\r
-register int i;\r
-\r
-for( i=0; i<NI; i++ )\r
- *xi++ = 0;\r
-}\r
-\r
-/* same, but don't touch the sign. */\r
-\r
-static void ecleazs(register short unsigned int *xi)\r
-{\r
-register int i;\r
-\r
-++xi;\r
-for(i=0; i<NI-1; i++)\r
- *xi++ = 0;\r
-}\r
-\r
-\r
-\r
-\r
-/* Move internal format number from a to b.\r
- */\r
-static void emovz(register short unsigned int *a, register short unsigned int *b)\r
-{\r
-register int i;\r
-\r
-for( i=0; i<NI-1; i++ )\r
- *b++ = *a++;\r
-/* clear low guard word */\r
-*b = 0;\r
-}\r
-\r
-/* Return nonzero if internal format number is a NaN.\r
- */\r
-\r
-static int eiisnan (short unsigned int *x)\r
-{\r
-int i;\r
-\r
-if( (x[E] & 0x7fff) == 0x7fff )\r
- {\r
- for( i=M+1; i<NI; i++ )\r
- {\r
- if( x[i] != 0 )\r
- return(1);\r
- }\r
- }\r
-return(0);\r
-}\r
-\r
-/* Return nonzero if internal format number is infinite. */\r
-\r
-static int \r
-eiisinf (x)\r
- unsigned short x[];\r
-{\r
-\r
-#ifdef NANS\r
- if (eiisnan (x))\r
- return (0);\r
-#endif\r
- if ((x[E] & 0x7fff) == 0x7fff)\r
- return (1);\r
- return (0);\r
-}\r
-\r
-/*\r
-; Compare significands of numbers in internal format.\r
-; Guard words are included in the comparison.\r
-;\r
-; unsigned short a[NI], b[NI];\r
-; cmpm( a, b );\r
-;\r
-; for the significands:\r
-; returns +1 if a > b\r
-; 0 if a == b\r
-; -1 if a < b\r
-*/\r
-static int ecmpm(register short unsigned int *a, register short unsigned int *b)\r
-{\r
-int i;\r
-\r
-a += M; /* skip up to significand area */\r
-b += M;\r
-for( i=M; i<NI; i++ )\r
- {\r
- if( *a++ != *b++ )\r
- goto difrnt;\r
- }\r
-return(0);\r
-\r
-difrnt:\r
-if( *(--a) > *(--b) )\r
- return(1);\r
-else\r
- return(-1);\r
-}\r
-\r
-\r
-/*\r
-; Shift significand down by 1 bit\r
-*/\r
-\r
-static void eshdn1(register short unsigned int *x)\r
-{\r
-register unsigned short bits;\r
-int i;\r
-\r
-x += M; /* point to significand area */\r
-\r
-bits = 0;\r
-for( i=M; i<NI; i++ )\r
- {\r
- if( *x & 1 )\r
- bits |= 1;\r
- *x >>= 1;\r
- if( bits & 2 )\r
- *x |= 0x8000;\r
- bits <<= 1;\r
- ++x;\r
- } \r
-}\r
-\r
-\r
-\r
-/*\r
-; Shift significand up by 1 bit\r
-*/\r
-\r
-static void eshup1(register short unsigned int *x)\r
-{\r
-register unsigned short bits;\r
-int i;\r
-\r
-x += NI-1;\r
-bits = 0;\r
-\r
-for( i=M; i<NI; i++ )\r
- {\r
- if( *x & 0x8000 )\r
- bits |= 1;\r
- *x <<= 1;\r
- if( bits & 2 )\r
- *x |= 1;\r
- bits <<= 1;\r
- --x;\r
- }\r
-}\r
-\r
-\r
-\r
-/*\r
-; Shift significand down by 8 bits\r
-*/\r
-\r
-static void eshdn8(register short unsigned int *x)\r
-{\r
-register unsigned short newbyt, oldbyt;\r
-int i;\r
-\r
-x += M;\r
-oldbyt = 0;\r
-for( i=M; i<NI; i++ )\r
- {\r
- newbyt = *x << 8;\r
- *x >>= 8;\r
- *x |= oldbyt;\r
- oldbyt = newbyt;\r
- ++x;\r
- }\r
-}\r
-\r
-/*\r
-; Shift significand up by 8 bits\r
-*/\r
-\r
-static void eshup8(register short unsigned int *x)\r
-{\r
-int i;\r
-register unsigned short newbyt, oldbyt;\r
-\r
-x += NI-1;\r
-oldbyt = 0;\r
-\r
-for( i=M; i<NI; i++ )\r
- {\r
- newbyt = *x >> 8;\r
- *x <<= 8;\r
- *x |= oldbyt;\r
- oldbyt = newbyt;\r
- --x;\r
- }\r
-}\r
-\r
-/*\r
-; Shift significand up by 16 bits\r
-*/\r
-\r
-static void eshup6(register short unsigned int *x)\r
-{\r
-int i;\r
-register unsigned short *p;\r
-\r
-p = x + M;\r
-x += M + 1;\r
-\r
-for( i=M; i<NI-1; i++ )\r
- *p++ = *x++;\r
-\r
-*p = 0;\r
-}\r
-\r
-/*\r
-; Shift significand down by 16 bits\r
-*/\r
-\r
-static void eshdn6(register short unsigned int *x)\r
-{\r
-int i;\r
-register unsigned short *p;\r
-\r
-x += NI-1;\r
-p = x + 1;\r
-\r
-for( i=M; i<NI-1; i++ )\r
- *(--p) = *(--x);\r
-\r
-*(--p) = 0;\r
-}\r
-\f\r
-/*\r
-; Add significands\r
-; x + y replaces y\r
-*/\r
-\r
-static void eaddm(short unsigned int *x, short unsigned int *y)\r
-{\r
-register unsigned long a;\r
-int i;\r
-unsigned int carry;\r
-\r
-x += NI-1;\r
-y += NI-1;\r
-carry = 0;\r
-for( i=M; i<NI; i++ )\r
- {\r
- a = (unsigned long )(*x) + (unsigned long )(*y) + carry;\r
- if( a & 0x10000 )\r
- carry = 1;\r
- else\r
- carry = 0;\r
- *y = (unsigned short )a;\r
- --x;\r
- --y;\r
- }\r
-}\r
-\r
-/*\r
-; Subtract significands\r
-; y - x replaces y\r
-*/\r
-\r
-static void esubm(short unsigned int *x, short unsigned int *y)\r
-{\r
-unsigned long a;\r
-int i;\r
-unsigned int carry;\r
-\r
-x += NI-1;\r
-y += NI-1;\r
-carry = 0;\r
-for( i=M; i<NI; i++ )\r
- {\r
- a = (unsigned long )(*y) - (unsigned long )(*x) - carry;\r
- if( a & 0x10000 )\r
- carry = 1;\r
- else\r
- carry = 0;\r
- *y = (unsigned short )a;\r
- --x;\r
- --y;\r
- }\r
-}\r
-\r
-\r
-/* Divide significands */\r
-\r
-\r
-/* Multiply significand of e-type number b\r
-by 16-bit quantity a, e-type result to c. */\r
-\r
-static void m16m(short unsigned int a, short unsigned int *b, short unsigned int *c)\r
-{\r
-register unsigned short *pp;\r
-register unsigned long carry;\r
-unsigned short *ps;\r
-unsigned short p[NI];\r
-unsigned long aa, m;\r
-int i;\r
-\r
-aa = a;\r
-pp = &p[NI-2];\r
-*pp++ = 0;\r
-*pp = 0;\r
-ps = &b[NI-1];\r
-\r
-for( i=M+1; i<NI; i++ )\r
- {\r
- if( *ps == 0 )\r
- {\r
- --ps;\r
- --pp;\r
- *(pp-1) = 0;\r
- }\r
- else\r
- {\r
- m = (unsigned long) aa * *ps--;\r
- carry = (m & 0xffff) + *pp;\r
- *pp-- = (unsigned short )carry;\r
- carry = (carry >> 16) + (m >> 16) + *pp;\r
- *pp = (unsigned short )carry;\r
- *(pp-1) = carry >> 16;\r
- }\r
- }\r
-for( i=M; i<NI; i++ )\r
- c[i] = p[i];\r
-}\r
-\r
-\r
-/* Divide significands. Neither the numerator nor the denominator\r
-is permitted to have its high guard word nonzero. */\r
-\r
-\r
-static int edivm(short unsigned int *den, short unsigned int *num, LDPARMS *ldp)\r
-{\r
-int i;\r
-register unsigned short *p;\r
-unsigned long tnum;\r
-unsigned short j, tdenm, tquot;\r
-unsigned short tprod[NI+1];\r
-unsigned short *equot = ldp->equot;\r
-\r
-p = &equot[0];\r
-*p++ = num[0];\r
-*p++ = num[1];\r
-\r
-for( i=M; i<NI; i++ )\r
- {\r
- *p++ = 0;\r
- }\r
-eshdn1( num );\r
-tdenm = den[M+1];\r
-for( i=M; i<NI; i++ )\r
- {\r
- /* Find trial quotient digit (the radix is 65536). */\r
- tnum = (((unsigned long) num[M]) << 16) + num[M+1];\r
-\r
- /* Do not execute the divide instruction if it will overflow. */\r
- if( (tdenm * 0xffffUL) < tnum )\r
- tquot = 0xffff;\r
- else\r
- tquot = tnum / tdenm;\r
-\r
- /* Prove that the divide worked. */\r
-/*\r
- tcheck = (unsigned long )tquot * tdenm;\r
- if( tnum - tcheck > tdenm )\r
- tquot = 0xffff;\r
-*/\r
- /* Multiply denominator by trial quotient digit. */\r
- m16m( tquot, den, tprod );\r
- /* The quotient digit may have been overestimated. */\r
- if( ecmpm( tprod, num ) > 0 )\r
- {\r
- tquot -= 1;\r
- esubm( den, tprod );\r
- if( ecmpm( tprod, num ) > 0 )\r
- {\r
- tquot -= 1;\r
- esubm( den, tprod );\r
- }\r
- }\r
-/*\r
- if( ecmpm( tprod, num ) > 0 )\r
- {\r
- eshow( "tprod", tprod );\r
- eshow( "num ", num );\r
- printf( "tnum = %08lx, tden = %04x, tquot = %04x\n",\r
- tnum, den[M+1], tquot );\r
- }\r
-*/\r
- esubm( tprod, num );\r
-/*\r
- if( ecmpm( num, den ) >= 0 )\r
- {\r
- eshow( "num ", num );\r
- eshow( "den ", den );\r
- printf( "tnum = %08lx, tden = %04x, tquot = %04x\n",\r
- tnum, den[M+1], tquot );\r
- }\r
-*/\r
- equot[i] = tquot;\r
- eshup6(num);\r
- }\r
-/* test for nonzero remainder after roundoff bit */\r
-p = &num[M];\r
-j = 0;\r
-for( i=M; i<NI; i++ )\r
- {\r
- j |= *p++;\r
- }\r
-if( j )\r
- j = 1;\r
-\r
-for( i=0; i<NI; i++ )\r
- num[i] = equot[i];\r
-\r
-return( (int )j );\r
-}\r
-\r
-\r
-\r
-/* Multiply significands */\r
-static int emulm(short unsigned int *a, short unsigned int *b, LDPARMS *ldp) \r
-{\r
-unsigned short *p, *q;\r
-unsigned short pprod[NI];\r
-unsigned short j;\r
-int i;\r
-unsigned short *equot = ldp->equot;\r
-\r
-equot[0] = b[0];\r
-equot[1] = b[1];\r
-for( i=M; i<NI; i++ )\r
- equot[i] = 0;\r
-\r
-j = 0;\r
-p = &a[NI-1];\r
-q = &equot[NI-1];\r
-for( i=M+1; i<NI; i++ )\r
- {\r
- if( *p == 0 )\r
- {\r
- --p;\r
- }\r
- else\r
- {\r
- m16m( *p--, b, pprod );\r
- eaddm(pprod, equot);\r
- }\r
- j |= *q;\r
- eshdn6(equot);\r
- }\r
-\r
-for( i=0; i<NI; i++ )\r
- b[i] = equot[i];\r
-\r
-/* return flag for lost nonzero bits */\r
-return( (int)j );\r
-}\r
-\r
-\r
-/*\r
-static void eshow(str, x)\r
-char *str;\r
-unsigned short *x;\r
-{\r
-int i;\r
-\r
-printf( "%s ", str );\r
-for( i=0; i<NI; i++ )\r
- printf( "%04x ", *x++ );\r
-printf( "\n" );\r
-}\r
-*/\r
-\r
-\r
-/*\r
- * Normalize and round off.\r
- *\r
- * The internal format number to be rounded is "s".\r
- * Input "lost" indicates whether the number is exact.\r
- * This is the so-called sticky bit.\r
- *\r
- * Input "subflg" indicates whether the number was obtained\r
- * by a subtraction operation. In that case if lost is nonzero\r
- * then the number is slightly smaller than indicated.\r
- *\r
- * Input "exp" is the biased exponent, which may be negative.\r
- * the exponent field of "s" is ignored but is replaced by\r
- * "exp" as adjusted by normalization and rounding.\r
- *\r
- * Input "rcntrl" is the rounding control.\r
- */\r
-\r
-\r
-static void emdnorm(short unsigned int *s, int lost, int subflg, long int exp, int rcntrl, LDPARMS *ldp)\r
-{\r
-int i, j;\r
-unsigned short r;\r
-\r
-/* Normalize */\r
-j = enormlz( s );\r
-\r
-/* a blank significand could mean either zero or infinity. */\r
-#ifndef INFINITY\r
-if( j > NBITS )\r
- {\r
- ecleazs( s );\r
- return;\r
- }\r
-#endif\r
-exp -= j;\r
-#ifndef INFINITY\r
-if( exp >= 32767L )\r
- goto overf;\r
-#else\r
-if( (j > NBITS) && (exp < 32767L) )\r
- {\r
- ecleazs( s );\r
- return;\r
- }\r
-#endif\r
-if( exp < 0L )\r
- {\r
- if( exp > (long )(-NBITS-1) )\r
- {\r
- j = (int )exp;\r
- i = eshift( s, j );\r
- if( i )\r
- lost = 1;\r
- }\r
- else\r
- {\r
- ecleazs( s );\r
- return;\r
- }\r
- }\r
-/* Round off, unless told not to by rcntrl. */\r
-if( rcntrl == 0 )\r
- goto mdfin;\r
-/* Set up rounding parameters if the control register changed. */\r
-if( ldp->rndprc != ldp->rlast )\r
- {\r
- ecleaz( ldp->rbit );\r
- switch( ldp->rndprc )\r
- {\r
- default:\r
- case NBITS:\r
- ldp->rw = NI-1; /* low guard word */\r
- ldp->rmsk = 0xffff;\r
- ldp->rmbit = 0x8000;\r
- ldp->rebit = 1;\r
- ldp->re = ldp->rw - 1;\r
- break;\r
- case 113:\r
- ldp->rw = 10;\r
- ldp->rmsk = 0x7fff;\r
- ldp->rmbit = 0x4000;\r
- ldp->rebit = 0x8000;\r
- ldp->re = ldp->rw;\r
- break;\r
- case 64:\r
- ldp->rw = 7;\r
- ldp->rmsk = 0xffff;\r
- ldp->rmbit = 0x8000;\r
- ldp->rebit = 1;\r
- ldp->re = ldp->rw-1;\r
- break;\r
-/* For DEC arithmetic */\r
- case 56:\r
- ldp->rw = 6;\r
- ldp->rmsk = 0xff;\r
- ldp->rmbit = 0x80;\r
- ldp->rebit = 0x100;\r
- ldp->re = ldp->rw;\r
- break;\r
- case 53:\r
- ldp->rw = 6;\r
- ldp->rmsk = 0x7ff;\r
- ldp->rmbit = 0x0400;\r
- ldp->rebit = 0x800;\r
- ldp->re = ldp->rw;\r
- break;\r
- case 24:\r
- ldp->rw = 4;\r
- ldp->rmsk = 0xff;\r
- ldp->rmbit = 0x80;\r
- ldp->rebit = 0x100;\r
- ldp->re = ldp->rw;\r
- break;\r
- }\r
- ldp->rbit[ldp->re] = ldp->rebit;\r
- ldp->rlast = ldp->rndprc;\r
- }\r
-\r
-/* Shift down 1 temporarily if the data structure has an implied\r
- * most significant bit and the number is denormal.\r
- * For rndprc = 64 or NBITS, there is no implied bit.\r
- * But Intel long double denormals lose one bit of significance even so.\r
- */\r
-#if IBMPC\r
-if( (exp <= 0) && (ldp->rndprc != NBITS) )\r
-#else\r
-if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS) )\r
-#endif\r
- {\r
- lost |= s[NI-1] & 1;\r
- eshdn1(s);\r
- }\r
-/* Clear out all bits below the rounding bit,\r
- * remembering in r if any were nonzero.\r
- */\r
-r = s[ldp->rw] & ldp->rmsk;\r
-if( ldp->rndprc < NBITS )\r
- {\r
- i = ldp->rw + 1;\r
- while( i < NI )\r
- {\r
- if( s[i] )\r
- r |= 1;\r
- s[i] = 0;\r
- ++i;\r
- }\r
- }\r
-s[ldp->rw] &= ~ldp->rmsk;\r
-if( (r & ldp->rmbit) != 0 )\r
- {\r
- if( r == ldp->rmbit )\r
- {\r
- if( lost == 0 )\r
- { /* round to even */\r
- if( (s[ldp->re] & ldp->rebit) == 0 )\r
- goto mddone;\r
- }\r
- else\r
- {\r
- if( subflg != 0 )\r
- goto mddone;\r
- }\r
- }\r
- eaddm( ldp->rbit, s );\r
- }\r
-mddone:\r
-#if IBMPC\r
-if( (exp <= 0) && (ldp->rndprc != NBITS) )\r
-#else\r
-if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->rndprc != NBITS) )\r
-#endif\r
- {\r
- eshup1(s);\r
- }\r
-if( s[2] != 0 )\r
- { /* overflow on roundoff */\r
- eshdn1(s);\r
- exp += 1;\r
- }\r
-mdfin:\r
-s[NI-1] = 0;\r
-if( exp >= 32767L )\r
- {\r
-#ifndef INFINITY\r
-overf:\r
-#endif\r
-#ifdef INFINITY\r
- s[1] = 32767;\r
- for( i=2; i<NI-1; i++ )\r
- s[i] = 0;\r
-#else\r
- s[1] = 32766;\r
- s[2] = 0;\r
- for( i=M+1; i<NI-1; i++ )\r
- s[i] = 0xffff;\r
- s[NI-1] = 0;\r
- if( (ldp->rndprc < 64) || (ldp->rndprc == 113) )\r
- {\r
- s[ldp->rw] &= ~ldp->rmsk;\r
- if( ldp->rndprc == 24 )\r
- {\r
- s[5] = 0;\r
- s[6] = 0;\r
- }\r
- }\r
-#endif\r
- return;\r
- }\r
-if( exp < 0 )\r
- s[1] = 0;\r
-else\r
- s[1] = (unsigned short )exp;\r
-}\r
-\r
-\r
-\r
-/*\r
-; Subtract external format numbers.\r
-;\r
-; unsigned short a[NE], b[NE], c[NE];\r
-; LDPARMS *ldp;\r
-; esub( a, b, c, ldp ); c = b - a\r
-*/\r
-\r
-static void esub(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp)\r
-{\r
-\r
-#ifdef NANS\r
-if( eisnan(a) )\r
- {\r
- emov (a, c);\r
- return;\r
- }\r
-if( eisnan(b) )\r
- {\r
- emov(b,c);\r
- return;\r
- }\r
-/* Infinity minus infinity is a NaN.\r
- * Test for subtracting infinities of the same sign.\r
- */\r
-if( eisinf(a) && eisinf(b) && ((eisneg (a) ^ eisneg (b)) == 0))\r
- {\r
- mtherr( "esub", DOMAIN );\r
- enan( c, NBITS );\r
- return;\r
- }\r
-#endif\r
-eadd1( a, b, c, 1, ldp );\r
-}\r
-\r
-\r
-\r
-static void eadd1(short unsigned int *a, short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp)\r
-{\r
-unsigned short ai[NI], bi[NI], ci[NI];\r
-int i, lost, j, k;\r
-long lt, lta, ltb;\r
-\r
-#ifdef INFINITY\r
-if( eisinf(a) )\r
- {\r
- emov(a,c);\r
- if( subflg )\r
- eneg(c);\r
- return;\r
- }\r
-if( eisinf(b) )\r
- {\r
- emov(b,c);\r
- return;\r
- }\r
-#endif\r
-emovi( a, ai );\r
-emovi( b, bi );\r
-if( subflg )\r
- ai[0] = ~ai[0];\r
-\r
-/* compare exponents */\r
-lta = ai[E];\r
-ltb = bi[E];\r
-lt = lta - ltb;\r
-if( lt > 0L )\r
- { /* put the larger number in bi */\r
- emovz( bi, ci );\r
- emovz( ai, bi );\r
- emovz( ci, ai );\r
- ltb = bi[E];\r
- lt = -lt;\r
- }\r
-lost = 0;\r
-if( lt != 0L )\r
- {\r
- if( lt < (long )(-NBITS-1) )\r
- goto done; /* answer same as larger addend */\r
- k = (int )lt;\r
- lost = eshift( ai, k ); /* shift the smaller number down */\r
- }\r
-else\r
- {\r
-/* exponents were the same, so must compare significands */\r
- i = ecmpm( ai, bi );\r
- if( i == 0 )\r
- { /* the numbers are identical in magnitude */\r
- /* if different signs, result is zero */\r
- if( ai[0] != bi[0] )\r
- {\r
- eclear(c);\r
- return;\r
- }\r
- /* if same sign, result is double */\r
- /* double denomalized tiny number */\r
- if( (bi[E] == 0) && ((bi[3] & 0x8000) == 0) )\r
- {\r
- eshup1( bi );\r
- goto done;\r
- }\r
- /* add 1 to exponent unless both are zero! */\r
- for( j=1; j<NI-1; j++ )\r
- {\r
- if( bi[j] != 0 )\r
- {\r
-/* This could overflow, but let emovo take care of that. */\r
- ltb += 1;\r
- break;\r
- }\r
- }\r
- bi[E] = (unsigned short )ltb;\r
- goto done;\r
- }\r
- if( i > 0 )\r
- { /* put the larger number in bi */\r
- emovz( bi, ci );\r
- emovz( ai, bi );\r
- emovz( ci, ai );\r
- }\r
- }\r
-if( ai[0] == bi[0] )\r
- {\r
- eaddm( ai, bi );\r
- subflg = 0;\r
- }\r
-else\r
- {\r
- esubm( ai, bi );\r
- subflg = 1;\r
- }\r
-emdnorm( bi, lost, subflg, ltb, 64, ldp );\r
-\r
-done:\r
-emovo( bi, c, ldp );\r
-}\r
-\r
-\r
-\r
-/*\r
-; Divide.\r
-;\r
-; unsigned short a[NE], b[NE], c[NE];\r
-; LDPARMS *ldp;\r
-; ediv( a, b, c, ldp ); c = b / a\r
-*/\r
-static void ediv(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp)\r
-{\r
-unsigned short ai[NI], bi[NI];\r
-int i;\r
-long lt, lta, ltb;\r
-\r
-#ifdef NANS\r
-/* Return any NaN input. */\r
-if( eisnan(a) )\r
- {\r
- emov(a,c);\r
- return;\r
- }\r
-if( eisnan(b) )\r
- {\r
- emov(b,c);\r
- return;\r
- }\r
-/* Zero over zero, or infinity over infinity, is a NaN. */\r
-if( ((ecmp(a,ezero) == 0) && (ecmp(b,ezero) == 0))\r
- || (eisinf (a) && eisinf (b)) )\r
- {\r
- mtherr( "ediv", DOMAIN );\r
- enan( c, NBITS );\r
- return;\r
- }\r
-#endif\r
-/* Infinity over anything else is infinity. */\r
-#ifdef INFINITY\r
-if( eisinf(b) )\r
- {\r
- if( eisneg(a) ^ eisneg(b) )\r
- *(c+(NE-1)) = 0x8000;\r
- else\r
- *(c+(NE-1)) = 0;\r
- einfin(c, ldp);\r
- return;\r
- }\r
-if( eisinf(a) )\r
- {\r
- eclear(c);\r
- return;\r
- }\r
-#endif\r
-emovi( a, ai );\r
-emovi( b, bi );\r
-lta = ai[E];\r
-ltb = bi[E];\r
-if( bi[E] == 0 )\r
- { /* See if numerator is zero. */\r
- for( i=1; i<NI-1; i++ )\r
- {\r
- if( bi[i] != 0 )\r
- {\r
- ltb -= enormlz( bi );\r
- goto dnzro1;\r
- }\r
- }\r
- eclear(c);\r
- return;\r
- }\r
-dnzro1:\r
-\r
-if( ai[E] == 0 )\r
- { /* possible divide by zero */\r
- for( i=1; i<NI-1; i++ )\r
- {\r
- if( ai[i] != 0 )\r
- {\r
- lta -= enormlz( ai );\r
- goto dnzro2;\r
- }\r
- }\r
- if( ai[0] == bi[0] )\r
- *(c+(NE-1)) = 0;\r
- else\r
- *(c+(NE-1)) = 0x8000;\r
- einfin(c, ldp);\r
- mtherr( "ediv", SING );\r
- return;\r
- }\r
-dnzro2:\r
-\r
-i = edivm( ai, bi, ldp );\r
-/* calculate exponent */\r
-lt = ltb - lta + EXONE;\r
-emdnorm( bi, i, 0, lt, 64, ldp );\r
-/* set the sign */\r
-if( ai[0] == bi[0] )\r
- bi[0] = 0;\r
-else\r
- bi[0] = 0Xffff;\r
-emovo( bi, c, ldp );\r
-}\r
-\r
-\r
-\r
-/*\r
-; Multiply.\r
-;\r
-; unsigned short a[NE], b[NE], c[NE];\r
-; LDPARMS *ldp\r
-; emul( a, b, c, ldp ); c = b * a\r
-*/\r
-static void emul(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp)\r
-{\r
-unsigned short ai[NI], bi[NI];\r
-int i, j;\r
-long lt, lta, ltb;\r
-\r
-#ifdef NANS\r
-/* NaN times anything is the same NaN. */\r
-if( eisnan(a) )\r
- {\r
- emov(a,c);\r
- return;\r
- }\r
-if( eisnan(b) )\r
- {\r
- emov(b,c);\r
- return;\r
- }\r
-/* Zero times infinity is a NaN. */\r
-if( (eisinf(a) && (ecmp(b,ezero) == 0))\r
- || (eisinf(b) && (ecmp(a,ezero) == 0)) )\r
- {\r
- mtherr( "emul", DOMAIN );\r
- enan( c, NBITS );\r
- return;\r
- }\r
-#endif\r
-/* Infinity times anything else is infinity. */\r
-#ifdef INFINITY\r
-if( eisinf(a) || eisinf(b) )\r
- {\r
- if( eisneg(a) ^ eisneg(b) )\r
- *(c+(NE-1)) = 0x8000;\r
- else\r
- *(c+(NE-1)) = 0;\r
- einfin(c, ldp);\r
- return;\r
- }\r
-#endif\r
-emovi( a, ai );\r
-emovi( b, bi );\r
-lta = ai[E];\r
-ltb = bi[E];\r
-if( ai[E] == 0 )\r
- {\r
- for( i=1; i<NI-1; i++ )\r
- {\r
- if( ai[i] != 0 )\r
- {\r
- lta -= enormlz( ai );\r
- goto mnzer1;\r
- }\r
- }\r
- eclear(c);\r
- return;\r
- }\r
-mnzer1:\r
-\r
-if( bi[E] == 0 )\r
- {\r
- for( i=1; i<NI-1; i++ )\r
- {\r
- if( bi[i] != 0 )\r
- {\r
- ltb -= enormlz( bi );\r
- goto mnzer2;\r
- }\r
- }\r
- eclear(c);\r
- return;\r
- }\r
-mnzer2:\r
-\r
-/* Multiply significands */\r
-j = emulm( ai, bi, ldp );\r
-/* calculate exponent */\r
-lt = lta + ltb - (EXONE - 1);\r
-emdnorm( bi, j, 0, lt, 64, ldp );\r
-/* calculate sign of product */\r
-if( ai[0] == bi[0] )\r
- bi[0] = 0;\r
-else\r
- bi[0] = 0xffff;\r
-emovo( bi, c, ldp );\r
-}\r
-\r
-\r
-\r
-#if LDBL_MANT_DIG > 64\r
-static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp)\r
-{\r
-register unsigned short r;\r
-unsigned short *e, *p;\r
-unsigned short yy[NI];\r
-int denorm, i;\r
-\r
-e = pe;\r
-denorm = 0;\r
-ecleaz(yy);\r
-#ifdef IBMPC\r
-e += 7;\r
-#endif\r
-r = *e;\r
-yy[0] = 0;\r
-if( r & 0x8000 )\r
- yy[0] = 0xffff;\r
-r &= 0x7fff;\r
-#ifdef INFINITY\r
-if( r == 0x7fff )\r
- {\r
-#ifdef NANS\r
-#ifdef IBMPC\r
- for( i=0; i<7; i++ )\r
- {\r
- if( pe[i] != 0 )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
- }\r
-#else /* !IBMPC */\r
- for( i=1; i<8; i++ )\r
- {\r
- if( pe[i] != 0 )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
- }\r
-#endif /* !IBMPC */\r
-#endif /* NANS */\r
- eclear( y );\r
- einfin( y );\r
- if( *e & 0x8000 )\r
- eneg(y);\r
- return;\r
- }\r
-#endif /* INFINITY */\r
-yy[E] = r;\r
-p = &yy[M + 1];\r
-#ifdef IBMPC\r
-for( i=0; i<7; i++ )\r
- *p++ = *(--e);\r
-#else /* IBMPC */\r
-++e;\r
-for( i=0; i<7; i++ )\r
- *p++ = *e++;\r
-#endif /* IBMPC */ \r
-/* If denormal, remove the implied bit; else shift down 1. */\r
-if( r == 0 )\r
- {\r
- yy[M] = 0;\r
- }\r
-else\r
- {\r
- yy[M] = 1;\r
- eshift( yy, -1 );\r
- }\r
-emovo(yy,y,ldp);\r
-}\r
-\r
-/* move out internal format to ieee long double */\r
-static void toe113(short unsigned int *a, short unsigned int *b)\r
-{\r
-register unsigned short *p, *q;\r
-unsigned short i;\r
-\r
-#ifdef NANS\r
-if( eiisnan(a) )\r
- {\r
- enan( b, 113 );\r
- return;\r
- }\r
-#endif\r
-p = a;\r
-#ifdef MIEEE\r
-q = b;\r
-#else\r
-q = b + 7; /* point to output exponent */\r
-#endif\r
-\r
-/* If not denormal, delete the implied bit. */\r
-if( a[E] != 0 )\r
- {\r
- eshup1 (a);\r
- }\r
-/* combine sign and exponent */\r
-i = *p++;\r
-#ifdef MIEEE\r
-if( i )\r
- *q++ = *p++ | 0x8000;\r
-else\r
- *q++ = *p++;\r
-#else\r
-if( i )\r
- *q-- = *p++ | 0x8000;\r
-else\r
- *q-- = *p++;\r
-#endif\r
-/* skip over guard word */\r
-++p;\r
-/* move the significand */\r
-#ifdef MIEEE\r
-for (i = 0; i < 7; i++)\r
- *q++ = *p++;\r
-#else\r
-for (i = 0; i < 7; i++)\r
- *q-- = *p++;\r
-#endif\r
-}\r
-#endif /* LDBL_MANT_DIG > 64 */\r
-\r
-\r
-#if LDBL_MANT_DIG == 64\r
-static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp)\r
-{\r
-unsigned short yy[NI];\r
-unsigned short *p, *q, *e;\r
-int i;\r
-\r
-e = pe;\r
-p = yy;\r
-\r
-for( i=0; i<NE-5; i++ )\r
- *p++ = 0;\r
-#ifdef IBMPC\r
-for( i=0; i<5; i++ )\r
- *p++ = *e++;\r
-#endif\r
-#ifdef DEC\r
-for( i=0; i<5; i++ )\r
- *p++ = *e++;\r
-#endif\r
-#ifdef MIEEE\r
-p = &yy[0] + (NE-1);\r
-*p-- = *e++;\r
-++e; /* MIEEE skips over 2nd short */\r
-for( i=0; i<4; i++ )\r
- *p-- = *e++;\r
-#endif\r
-\r
-#ifdef IBMPC\r
-/* For Intel long double, shift denormal significand up 1\r
- -- but only if the top significand bit is zero. */\r
-if((yy[NE-1] & 0x7fff) == 0 && (yy[NE-2] & 0x8000) == 0)\r
- {\r
- unsigned short temp[NI+1];\r
- emovi(yy, temp);\r
- eshup1(temp);\r
- emovo(temp,y,ldp);\r
- return;\r
- }\r
-#endif\r
-#ifdef INFINITY\r
-/* Point to the exponent field. */\r
-p = &yy[NE-1];\r
-if( *p == 0x7fff )\r
- {\r
-#ifdef NANS\r
-#ifdef IBMPC\r
- for( i=0; i<4; i++ )\r
- {\r
- if((i != 3 && pe[i] != 0)\r
- /* Check for Intel long double infinity pattern. */\r
- || (i == 3 && pe[i] != 0x8000))\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
- }\r
-#endif\r
-#ifdef MIEEE\r
- for( i=2; i<=5; i++ )\r
- {\r
- if( pe[i] != 0 )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
- }\r
-#endif\r
-#endif /* NANS */\r
- eclear( y );\r
- einfin( y, ldp );\r
- if( *p & 0x8000 )\r
- eneg(y);\r
- return;\r
- }\r
-#endif /* INFINITY */\r
-p = yy;\r
-q = y;\r
-for( i=0; i<NE; i++ )\r
- *q++ = *p++;\r
-}\r
-\r
-/* move out internal format to ieee long double */\r
-static void toe64(short unsigned int *a, short unsigned int *b)\r
-{\r
-register unsigned short *p, *q;\r
-unsigned short i;\r
-\r
-#ifdef NANS\r
-if( eiisnan(a) )\r
- {\r
- enan( b, 64 );\r
- return;\r
- }\r
-#endif\r
-#ifdef IBMPC\r
-/* Shift Intel denormal significand down 1. */\r
-if( a[E] == 0 )\r
- eshdn1(a);\r
-#endif\r
-p = a;\r
-#ifdef MIEEE\r
-q = b;\r
-#else\r
-q = b + 4; /* point to output exponent */\r
-/* NOTE: Intel data type is 96 bits wide, clear the last word here. */\r
-*(q+1)= 0;\r
-#endif\r
-\r
-/* combine sign and exponent */\r
-i = *p++;\r
-#ifdef MIEEE\r
-if( i )\r
- *q++ = *p++ | 0x8000;\r
-else\r
- *q++ = *p++;\r
-*q++ = 0; /* leave 2nd short blank */\r
-#else\r
-if( i )\r
- *q-- = *p++ | 0x8000;\r
-else\r
- *q-- = *p++;\r
-#endif\r
-/* skip over guard word */\r
-++p;\r
-/* move the significand */\r
-#ifdef MIEEE\r
-for( i=0; i<4; i++ )\r
- *q++ = *p++;\r
-#else\r
-#ifdef INFINITY\r
-#ifdef IBMPC\r
-if (eiisinf (a))\r
- {\r
- /* Intel long double infinity. */\r
- *q-- = 0x8000;\r
- *q-- = 0;\r
- *q-- = 0;\r
- *q = 0;\r
- return;\r
- }\r
-#endif /* IBMPC */\r
-#endif /* INFINITY */\r
-for( i=0; i<4; i++ )\r
- *q-- = *p++;\r
-#endif\r
-}\r
-\r
-#endif /* LDBL_MANT_DIG == 64 */\r
-\r
-#if LDBL_MANT_DIG == 53\r
-/*\r
-; Convert IEEE double precision to e type\r
-; double d;\r
-; unsigned short x[N+2];\r
-; e53toe( &d, x );\r
-*/\r
-static void e53toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp)\r
-{\r
-#ifdef DEC\r
-\r
-dectoe( pe, y ); /* see etodec.c */\r
-\r
-#else\r
-\r
-register unsigned short r;\r
-register unsigned short *p, *e;\r
-unsigned short yy[NI];\r
-int denorm, k;\r
-\r
-e = pe;\r
-denorm = 0; /* flag if denormalized number */\r
-ecleaz(yy);\r
-#ifdef IBMPC\r
-e += 3;\r
-#endif\r
-#ifdef DEC\r
-e += 3;\r
-#endif \r
-r = *e;\r
-yy[0] = 0;\r
-if( r & 0x8000 )\r
- yy[0] = 0xffff;\r
-yy[M] = (r & 0x0f) | 0x10;\r
-r &= ~0x800f; /* strip sign and 4 significand bits */\r
-#ifdef INFINITY\r
-if( r == 0x7ff0 )\r
- {\r
-#ifdef NANS\r
-#ifdef IBMPC\r
- if( ((pe[3] & 0xf) != 0) || (pe[2] != 0)\r
- || (pe[1] != 0) || (pe[0] != 0) )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
-#else /* !IBMPC */\r
- if( ((pe[0] & 0xf) != 0) || (pe[1] != 0)\r
- || (pe[2] != 0) || (pe[3] != 0) )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
-#endif /* !IBMPC */\r
-#endif /* NANS */\r
- eclear( y );\r
- einfin( y );\r
- if( yy[0] )\r
- eneg(y);\r
- return;\r
- }\r
-#endif\r
-r >>= 4;\r
-/* If zero exponent, then the significand is denormalized.\r
- * So, take back the understood high significand bit. */ \r
-if( r == 0 )\r
- {\r
- denorm = 1;\r
- yy[M] &= ~0x10;\r
- }\r
-r += EXONE - 01777;\r
-yy[E] = r;\r
-p = &yy[M+1];\r
-#ifdef IBMPC\r
-*p++ = *(--e);\r
-*p++ = *(--e);\r
-*p++ = *(--e);\r
-#else /* !IBMPC */\r
-++e;\r
-*p++ = *e++;\r
-*p++ = *e++;\r
-*p++ = *e++;\r
-#endif /* !IBMPC */\r
-(void )eshift( yy, -5 );\r
-if( denorm )\r
- { /* if zero exponent, then normalize the significand */\r
- if( (k = enormlz(yy)) > NBITS )\r
- ecleazs(yy);\r
- else\r
- yy[E] -= (unsigned short )(k-1);\r
- }\r
-emovo( yy, y, ldp );\r
-#endif /* !DEC */\r
-}\r
-\r
-/*\r
-; e type to IEEE double precision\r
-; double d;\r
-; unsigned short x[NE];\r
-; etoe53( x, &d );\r
-*/\r
-\r
-#ifdef DEC\r
-\r
-static void etoe53( x, e )\r
-unsigned short *x, *e;\r
-{\r
-etodec( x, e ); /* see etodec.c */\r
-}\r
-\r
-static void toe53( x, y )\r
-unsigned short *x, *y;\r
-{\r
-todec( x, y );\r
-}\r
-\r
-#else\r
-\r
-static void toe53(short unsigned int *x, short unsigned int *y)\r
-{\r
-unsigned short i;\r
-unsigned short *p;\r
-\r
-\r
-#ifdef NANS\r
-if( eiisnan(x) )\r
- {\r
- enan( y, 53 );\r
- return;\r
- }\r
-#endif\r
-p = &x[0];\r
-#ifdef IBMPC\r
-y += 3;\r
-#endif\r
-#ifdef DEC\r
-y += 3;\r
-#endif\r
-*y = 0; /* output high order */\r
-if( *p++ )\r
- *y = 0x8000; /* output sign bit */\r
-\r
-i = *p++;\r
-if( i >= (unsigned int )2047 )\r
- { /* Saturate at largest number less than infinity. */\r
-#ifdef INFINITY\r
- *y |= 0x7ff0;\r
-#ifdef IBMPC\r
- *(--y) = 0;\r
- *(--y) = 0;\r
- *(--y) = 0;\r
-#else /* !IBMPC */\r
- ++y;\r
- *y++ = 0;\r
- *y++ = 0;\r
- *y++ = 0;\r
-#endif /* IBMPC */\r
-#else /* !INFINITY */\r
- *y |= (unsigned short )0x7fef;\r
-#ifdef IBMPC\r
- *(--y) = 0xffff;\r
- *(--y) = 0xffff;\r
- *(--y) = 0xffff;\r
-#else /* !IBMPC */\r
- ++y;\r
- *y++ = 0xffff;\r
- *y++ = 0xffff;\r
- *y++ = 0xffff;\r
-#endif\r
-#endif /* !INFINITY */\r
- return;\r
- }\r
-if( i == 0 )\r
- {\r
- (void )eshift( x, 4 );\r
- }\r
-else\r
- {\r
- i <<= 4;\r
- (void )eshift( x, 5 );\r
- }\r
-i |= *p++ & (unsigned short )0x0f; /* *p = xi[M] */\r
-*y |= (unsigned short )i; /* high order output already has sign bit set */\r
-#ifdef IBMPC\r
-*(--y) = *p++;\r
-*(--y) = *p++;\r
-*(--y) = *p;\r
-#else /* !IBMPC */\r
-++y;\r
-*y++ = *p++;\r
-*y++ = *p++;\r
-*y++ = *p++;\r
-#endif /* !IBMPC */\r
-}\r
-\r
-#endif /* not DEC */\r
-#endif /* LDBL_MANT_DIG == 53 */\r
-\r
-#if LDBL_MANT_DIG == 24\r
-/*\r
-; Convert IEEE single precision to e type\r
-; float d;\r
-; unsigned short x[N+2];\r
-; dtox( &d, x );\r
-*/\r
-void e24toe( short unsigned int *pe, short unsigned int *y, LDPARMS *ldp )\r
-{\r
-register unsigned short r;\r
-register unsigned short *p, *e;\r
-unsigned short yy[NI];\r
-int denorm, k;\r
-\r
-e = pe;\r
-denorm = 0; /* flag if denormalized number */\r
-ecleaz(yy);\r
-#ifdef IBMPC\r
-e += 1;\r
-#endif\r
-#ifdef DEC\r
-e += 1;\r
-#endif\r
-r = *e;\r
-yy[0] = 0;\r
-if( r & 0x8000 )\r
- yy[0] = 0xffff;\r
-yy[M] = (r & 0x7f) | 0200;\r
-r &= ~0x807f; /* strip sign and 7 significand bits */\r
-#ifdef INFINITY\r
-if( r == 0x7f80 )\r
- {\r
-#ifdef NANS\r
-#ifdef MIEEE\r
- if( ((pe[0] & 0x7f) != 0) || (pe[1] != 0) )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
-#else /* !MIEEE */\r
- if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) )\r
- {\r
- enan( y, NBITS );\r
- return;\r
- }\r
-#endif /* !MIEEE */\r
-#endif /* NANS */\r
- eclear( y );\r
- einfin( y );\r
- if( yy[0] )\r
- eneg(y);\r
- return;\r
- }\r
-#endif\r
-r >>= 7;\r
-/* If zero exponent, then the significand is denormalized.\r
- * So, take back the understood high significand bit. */ \r
-if( r == 0 )\r
- {\r
- denorm = 1;\r
- yy[M] &= ~0200;\r
- }\r
-r += EXONE - 0177;\r
-yy[E] = r;\r
-p = &yy[M+1];\r
-#ifdef IBMPC\r
-*p++ = *(--e);\r
-#endif\r
-#ifdef DEC\r
-*p++ = *(--e);\r
-#endif\r
-#ifdef MIEEE\r
-++e;\r
-*p++ = *e++;\r
-#endif\r
-(void )eshift( yy, -8 );\r
-if( denorm )\r
- { /* if zero exponent, then normalize the significand */\r
- if( (k = enormlz(yy)) > NBITS )\r
- ecleazs(yy);\r
- else\r
- yy[E] -= (unsigned short )(k-1);\r
- }\r
-emovo( yy, y, ldp );\r
-}\r
-\r
-static void toe24(short unsigned int *x, short unsigned int *y)\r
-{\r
-unsigned short i;\r
-unsigned short *p;\r
-\r
-#ifdef NANS\r
-if( eiisnan(x) )\r
- {\r
- enan( y, 24 );\r
- return;\r
- }\r
-#endif\r
-p = &x[0];\r
-#ifdef IBMPC\r
-y += 1;\r
-#endif\r
-#ifdef DEC\r
-y += 1;\r
-#endif\r
-*y = 0; /* output high order */\r
-if( *p++ )\r
- *y = 0x8000; /* output sign bit */\r
-\r
-i = *p++;\r
-if( i >= 255 )\r
- { /* Saturate at largest number less than infinity. */\r
-#ifdef INFINITY\r
- *y |= (unsigned short )0x7f80;\r
-#ifdef IBMPC\r
- *(--y) = 0;\r
-#endif\r
-#ifdef DEC\r
- *(--y) = 0;\r
-#endif\r
-#ifdef MIEEE\r
- ++y;\r
- *y = 0;\r
-#endif\r
-#else /* !INFINITY */\r
- *y |= (unsigned short )0x7f7f;\r
-#ifdef IBMPC\r
- *(--y) = 0xffff;\r
-#endif\r
-#ifdef DEC\r
- *(--y) = 0xffff;\r
-#endif\r
-#ifdef MIEEE\r
- ++y;\r
- *y = 0xffff;\r
-#endif\r
-#endif /* !INFINITY */\r
- return;\r
- }\r
-if( i == 0 )\r
- {\r
- (void )eshift( x, 7 );\r
- }\r
-else\r
- {\r
- i <<= 7;\r
- (void )eshift( x, 8 );\r
- }\r
-i |= *p++ & (unsigned short )0x7f; /* *p = xi[M] */\r
-*y |= i; /* high order output already has sign bit set */\r
-#ifdef IBMPC\r
-*(--y) = *p;\r
-#endif\r
-#ifdef DEC\r
-*(--y) = *p;\r
-#endif\r
-#ifdef MIEEE\r
-++y;\r
-*y = *p;\r
-#endif\r
-}\r
-#endif /* LDBL_MANT_DIG == 24 */\r
-\r
-/* Compare two e type numbers.\r
- *\r
- * unsigned short a[NE], b[NE];\r
- * ecmp( a, b );\r
- *\r
- * returns +1 if a > b\r
- * 0 if a == b\r
- * -1 if a < b\r
- * -2 if either a or b is a NaN.\r
- */\r
-static int ecmp(short unsigned int *a, short unsigned int *b)\r
-{\r
-unsigned short ai[NI], bi[NI];\r
-register unsigned short *p, *q;\r
-register int i;\r
-int msign;\r
-\r
-#ifdef NANS\r
-if (eisnan (a) || eisnan (b))\r
- return( -2 );\r
-#endif\r
-emovi( a, ai );\r
-p = ai;\r
-emovi( b, bi );\r
-q = bi;\r
-\r
-if( *p != *q )\r
- { /* the signs are different */\r
-/* -0 equals + 0 */\r
- for( i=1; i<NI-1; i++ )\r
- {\r
- if( ai[i] != 0 )\r
- goto nzro;\r
- if( bi[i] != 0 )\r
- goto nzro;\r
- }\r
- return(0);\r
-nzro:\r
- if( *p == 0 )\r
- return( 1 );\r
- else\r
- return( -1 );\r
- }\r
-/* both are the same sign */\r
-if( *p == 0 )\r
- msign = 1;\r
-else\r
- msign = -1;\r
-i = NI-1;\r
-do\r
- {\r
- if( *p++ != *q++ )\r
- {\r
- goto diff;\r
- }\r
- }\r
-while( --i > 0 );\r
-\r
-return(0); /* equality */\r
-\r
-\r
-\r
-diff:\r
-\r
-if( *(--p) > *(--q) )\r
- return( msign ); /* p is bigger */\r
-else\r
- return( -msign ); /* p is littler */\r
-}\r
-\r
-\r
-/*\r
-; Shift significand\r
-;\r
-; Shifts significand area up or down by the number of bits\r
-; given by the variable sc.\r
-*/\r
-static int eshift(short unsigned int *x, int sc)\r
-{\r
-unsigned short lost;\r
-unsigned short *p;\r
-\r
-if( sc == 0 )\r
- return( 0 );\r
-\r
-lost = 0;\r
-p = x + NI-1;\r
-\r
-if( sc < 0 )\r
- {\r
- sc = -sc;\r
- while( sc >= 16 )\r
- {\r
- lost |= *p; /* remember lost bits */\r
- eshdn6(x);\r
- sc -= 16;\r
- }\r
-\r
- while( sc >= 8 )\r
- {\r
- lost |= *p & 0xff;\r
- eshdn8(x);\r
- sc -= 8;\r
- }\r
-\r
- while( sc > 0 )\r
- {\r
- lost |= *p & 1;\r
- eshdn1(x);\r
- sc -= 1;\r
- }\r
- }\r
-else\r
- {\r
- while( sc >= 16 )\r
- {\r
- eshup6(x);\r
- sc -= 16;\r
- }\r
-\r
- while( sc >= 8 )\r
- {\r
- eshup8(x);\r
- sc -= 8;\r
- }\r
-\r
- while( sc > 0 )\r
- {\r
- eshup1(x);\r
- sc -= 1;\r
- }\r
- }\r
-if( lost )\r
- lost = 1;\r
-return( (int )lost );\r
-}\r
-\r
-\r
-\r
-/*\r
-; normalize\r
-;\r
-; Shift normalizes the significand area pointed to by argument\r
-; shift count (up = positive) is returned.\r
-*/\r
-static int enormlz(short unsigned int *x)\r
-{\r
-register unsigned short *p;\r
-int sc;\r
-\r
-sc = 0;\r
-p = &x[M];\r
-if( *p != 0 )\r
- goto normdn;\r
-++p;\r
-if( *p & 0x8000 )\r
- return( 0 ); /* already normalized */\r
-while( *p == 0 )\r
- {\r
- eshup6(x);\r
- sc += 16;\r
-/* With guard word, there are NBITS+16 bits available.\r
- * return true if all are zero.\r
- */\r
- if( sc > NBITS )\r
- return( sc );\r
- }\r
-/* see if high byte is zero */\r
-while( (*p & 0xff00) == 0 )\r
- {\r
- eshup8(x);\r
- sc += 8;\r
- }\r
-/* now shift 1 bit at a time */\r
-while( (*p & 0x8000) == 0)\r
- {\r
- eshup1(x);\r
- sc += 1;\r
- if( sc > (NBITS+16) )\r
- {\r
- mtherr( "enormlz", UNDERFLOW );\r
- return( sc );\r
- }\r
- }\r
-return( sc );\r
-\r
-/* Normalize by shifting down out of the high guard word\r
- of the significand */\r
-normdn:\r
-\r
-if( *p & 0xff00 )\r
- {\r
- eshdn8(x);\r
- sc -= 8;\r
- }\r
-while( *p != 0 )\r
- {\r
- eshdn1(x);\r
- sc -= 1;\r
-\r
- if( sc < -NBITS )\r
- {\r
- mtherr( "enormlz", OVERFLOW );\r
- return( sc );\r
- }\r
- }\r
-return( sc );\r
-}\r
-\r
-\r
-\r
-\r
-/* Convert e type number to decimal format ASCII string.\r
- * The constants are for 64 bit precision.\r
- */\r
-\r
-#define NTEN 12\r
-#define MAXP 4096\r
-\r
-#if NE == 10\r
-static unsigned short etens[NTEN + 1][NE] =\r
-{\r
- {0x6576, 0x4a92, 0x804a, 0x153f,\r
- 0xc94c, 0x979a, 0x8a20, 0x5202, 0xc460, 0x7525,}, /* 10**4096 */\r
- {0x6a32, 0xce52, 0x329a, 0x28ce,\r
- 0xa74d, 0x5de4, 0xc53d, 0x3b5d, 0x9e8b, 0x5a92,}, /* 10**2048 */\r
- {0x526c, 0x50ce, 0xf18b, 0x3d28,\r
- 0x650d, 0x0c17, 0x8175, 0x7586, 0xc976, 0x4d48,},\r
- {0x9c66, 0x58f8, 0xbc50, 0x5c54,\r
- 0xcc65, 0x91c6, 0xa60e, 0xa0ae, 0xe319, 0x46a3,},\r
- {0x851e, 0xeab7, 0x98fe, 0x901b,\r
- 0xddbb, 0xde8d, 0x9df9, 0xebfb, 0xaa7e, 0x4351,},\r
- {0x0235, 0x0137, 0x36b1, 0x336c,\r
- 0xc66f, 0x8cdf, 0x80e9, 0x47c9, 0x93ba, 0x41a8,},\r
- {0x50f8, 0x25fb, 0xc76b, 0x6b71,\r
- 0x3cbf, 0xa6d5, 0xffcf, 0x1f49, 0xc278, 0x40d3,},\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0xf020, 0xb59d, 0x2b70, 0xada8, 0x9dc5, 0x4069,},\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0400, 0xc9bf, 0x8e1b, 0x4034,},\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0000, 0x2000, 0xbebc, 0x4019,},\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0000, 0x0000, 0x9c40, 0x400c,},\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0000, 0x0000, 0xc800, 0x4005,},\r
- {0x0000, 0x0000, 0x0000, 0x0000,\r
- 0x0000, 0x0000, 0x0000, 0x0000, 0xa000, 0x4002,}, /* 10**1 */\r
-};\r
-\r
-static unsigned short emtens[NTEN + 1][NE] =\r
-{\r
- {0x2030, 0xcffc, 0xa1c3, 0x8123,\r
- 0x2de3, 0x9fde, 0xd2ce, 0x04c8, 0xa6dd, 0x0ad8,}, /* 10**-4096 */\r
- {0x8264, 0xd2cb, 0xf2ea, 0x12d4,\r
- 0x4925, 0x2de4, 0x3436, 0x534f, 0xceae, 0x256b,}, /* 10**-2048 */\r
- {0xf53f, 0xf698, 0x6bd3, 0x0158,\r
- 0x87a6, 0xc0bd, 0xda57, 0x82a5, 0xa2a6, 0x32b5,},\r
- {0xe731, 0x04d4, 0xe3f2, 0xd332,\r
- 0x7132, 0xd21c, 0xdb23, 0xee32, 0x9049, 0x395a,},\r
- {0xa23e, 0x5308, 0xfefb, 0x1155,\r
- 0xfa91, 0x1939, 0x637a, 0x4325, 0xc031, 0x3cac,},\r
- {0xe26d, 0xdbde, 0xd05d, 0xb3f6,\r
- 0xac7c, 0xe4a0, 0x64bc, 0x467c, 0xddd0, 0x3e55,},\r
- {0x2a20, 0x6224, 0x47b3, 0x98d7,\r
- 0x3f23, 0xe9a5, 0xa539, 0xea27, 0xa87f, 0x3f2a,},\r
- {0x0b5b, 0x4af2, 0xa581, 0x18ed,\r
- 0x67de, 0x94ba, 0x4539, 0x1ead, 0xcfb1, 0x3f94,},\r
- {0xbf71, 0xa9b3, 0x7989, 0xbe68,\r
- 0x4c2e, 0xe15b, 0xc44d, 0x94be, 0xe695, 0x3fc9,},\r
- {0x3d4d, 0x7c3d, 0x36ba, 0x0d2b,\r
- 0xfdc2, 0xcefc, 0x8461, 0x7711, 0xabcc, 0x3fe4,},\r
- {0xc155, 0xa4a8, 0x404e, 0x6113,\r
- 0xd3c3, 0x652b, 0xe219, 0x1758, 0xd1b7, 0x3ff1,},\r
- {0xd70a, 0x70a3, 0x0a3d, 0xa3d7,\r
- 0x3d70, 0xd70a, 0x70a3, 0x0a3d, 0xa3d7, 0x3ff8,},\r
- {0xcccd, 0xcccc, 0xcccc, 0xcccc,\r
- 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0xcccc, 0x3ffb,}, /* 10**-1 */\r
-};\r
-#else\r
-static unsigned short etens[NTEN+1][NE] = {\r
-{0xc94c,0x979a,0x8a20,0x5202,0xc460,0x7525,},/* 10**4096 */\r
-{0xa74d,0x5de4,0xc53d,0x3b5d,0x9e8b,0x5a92,},/* 10**2048 */\r
-{0x650d,0x0c17,0x8175,0x7586,0xc976,0x4d48,},\r
-{0xcc65,0x91c6,0xa60e,0xa0ae,0xe319,0x46a3,},\r
-{0xddbc,0xde8d,0x9df9,0xebfb,0xaa7e,0x4351,},\r
-{0xc66f,0x8cdf,0x80e9,0x47c9,0x93ba,0x41a8,},\r
-{0x3cbf,0xa6d5,0xffcf,0x1f49,0xc278,0x40d3,},\r
-{0xf020,0xb59d,0x2b70,0xada8,0x9dc5,0x4069,},\r
-{0x0000,0x0000,0x0400,0xc9bf,0x8e1b,0x4034,},\r
-{0x0000,0x0000,0x0000,0x2000,0xbebc,0x4019,},\r
-{0x0000,0x0000,0x0000,0x0000,0x9c40,0x400c,},\r
-{0x0000,0x0000,0x0000,0x0000,0xc800,0x4005,},\r
-{0x0000,0x0000,0x0000,0x0000,0xa000,0x4002,}, /* 10**1 */\r
-};\r
-\r
-static unsigned short emtens[NTEN+1][NE] = {\r
-{0x2de4,0x9fde,0xd2ce,0x04c8,0xa6dd,0x0ad8,}, /* 10**-4096 */\r
-{0x4925,0x2de4,0x3436,0x534f,0xceae,0x256b,}, /* 10**-2048 */\r
-{0x87a6,0xc0bd,0xda57,0x82a5,0xa2a6,0x32b5,},\r
-{0x7133,0xd21c,0xdb23,0xee32,0x9049,0x395a,},\r
-{0xfa91,0x1939,0x637a,0x4325,0xc031,0x3cac,},\r
-{0xac7d,0xe4a0,0x64bc,0x467c,0xddd0,0x3e55,},\r
-{0x3f24,0xe9a5,0xa539,0xea27,0xa87f,0x3f2a,},\r
-{0x67de,0x94ba,0x4539,0x1ead,0xcfb1,0x3f94,},\r
-{0x4c2f,0xe15b,0xc44d,0x94be,0xe695,0x3fc9,},\r
-{0xfdc2,0xcefc,0x8461,0x7711,0xabcc,0x3fe4,},\r
-{0xd3c3,0x652b,0xe219,0x1758,0xd1b7,0x3ff1,},\r
-{0x3d71,0xd70a,0x70a3,0x0a3d,0xa3d7,0x3ff8,},\r
-{0xcccd,0xcccc,0xcccc,0xcccc,0xcccc,0x3ffb,}, /* 10**-1 */\r
-};\r
-#endif\r
-\r
-\r
-\r
-/* ASCII string outputs for unix */\r
-\r
-\r
-#if 0\r
-void _IO_ldtostr(x, string, ndigs, flags, fmt)\r
-long double *x;\r
-char *string;\r
-int ndigs;\r
-int flags;\r
-char fmt;\r
-{\r
-unsigned short w[NI];\r
-char *t, *u;\r
-LDPARMS rnd;\r
-LDPARMS *ldp = &rnd;\r
-\r
-rnd.rlast = -1;\r
-rnd.rndprc = NBITS;\r
-\r
-if (sizeof(long double) == 16)\r
- e113toe( (unsigned short *)x, w, ldp );\r
-else\r
- e64toe( (unsigned short *)x, w, ldp );\r
-\r
-etoasc( w, string, ndigs, -1, ldp );\r
-if( ndigs == 0 && flags == 0 )\r
- {\r
- /* Delete the decimal point unless alternate format. */\r
- t = string; \r
- while( *t != '.' )\r
- ++t;\r
- u = t + 1;\r
- while( *t != '\0' )\r
- *t++ = *u++;\r
- }\r
-if (*string == ' ')\r
- {\r
- t = string; \r
- u = t + 1;\r
- while( *t != '\0' )\r
- *t++ = *u++;\r
- }\r
-if (fmt == 'E')\r
- {\r
- t = string; \r
- while( *t != 'e' )\r
- ++t;\r
- *t = 'E';\r
- }\r
-}\r
-\r
-#endif\r
-\r
-/* This routine will not return more than NDEC+1 digits. */\r
-\r
-char *\r
-_ldtoa_r (struct _reent *ptr, long double d, int mode, int ndigits, int *decpt, \r
- int *sign, char **rve)\r
-{\r
-unsigned short e[NI];\r
-char *s, *p;\r
-int k;\r
-LDPARMS rnd;\r
-LDPARMS *ldp = &rnd;\r
-char *outstr;\r
-\r
-rnd.rlast = -1;\r
-rnd.rndprc = NBITS;\r
-\r
-/* reentrancy addition to use mprec storage pool */\r
-if (ptr->_result)\r
- {\r
- ptr->_result->_k = ptr->_result_k;\r
- ptr->_result->_maxwds = 1 << ptr->_result_k;\r
- Bfree (ptr, ptr->_result);\r
- ptr->_result = 0;\r
- }\r
-\r
-#if LDBL_MANT_DIG == 24\r
-e24toe( (unsigned short *)&d, e, ldp );\r
-#elif LDBL_MANT_DIG == 53\r
-e53toe( (unsigned short *)&d, e, ldp );\r
-#elif LDBL_MANT_DIG == 64\r
-e64toe( (unsigned short *)&d, e, ldp );\r
-#else\r
-e113toe( (unsigned short *)&d, e, ldp );\r
-#endif\r
-\r
-if( eisneg(e) )\r
- *sign = 1;\r
-else\r
- *sign = 0;\r
-/* Mode 3 is "f" format. */\r
-if( mode != 3 )\r
- ndigits -= 1;\r
-/* Mode 0 is for %.999 format, which is supposed to give a\r
- minimum length string that will convert back to the same binary value.\r
- For now, just ask for 20 digits which is enough but sometimes too many. */\r
-if( mode == 0 )\r
- ndigits = 20;\r
-/* This sanity limit must agree with the corresponding one in etoasc, to\r
- keep straight the returned value of outexpon. */\r
-if( ndigits > NDEC )\r
- ndigits = NDEC;\r
-\r
-/* reentrancy addition to use mprec storage pool */\r
-ptr->_result = Balloc (ptr, 3);\r
-ptr->_result_k = 3;\r
-outstr = (char *)ptr->_result;\r
-\r
-etoasc( e, outstr, ndigits, mode, ldp );\r
-s = outstr;\r
-if( eisinf(e) || eisnan(e) )\r
- {\r
- *decpt = 9999;\r
- goto stripspaces;\r
- }\r
-*decpt = ldp->outexpon + 1;\r
-\r
-/* Transform the string returned by etoasc into what the caller wants. */\r
-\r
-/* Look for decimal point and delete it from the string. */\r
-s = outstr;\r
-while( *s != '\0' )\r
- {\r
- if( *s == '.' )\r
- goto yesdecpt;\r
- ++s;\r
- }\r
-goto nodecpt;\r
-\r
-yesdecpt:\r
-\r
-/* Delete the decimal point. */\r
-while( *s != '\0' )\r
- {\r
- *s = *(s+1);\r
- ++s;\r
- }\r
-\r
-nodecpt:\r
-\r
-/* Back up over the exponent field. */\r
-while( *s != 'E' && s > outstr)\r
- --s;\r
-*s = '\0';\r
-\r
-stripspaces:\r
-\r
-/* Strip leading spaces and sign. */\r
-p = outstr;\r
-while( *p == ' ' || *p == '-')\r
- ++p;\r
-\r
-/* Find new end of string. */\r
-s = outstr;\r
-while( (*s++ = *p++) != '\0' )\r
- ;\r
---s;\r
-\r
-/* Strip trailing zeros. */\r
-if( mode == 2 )\r
- k = 1;\r
-else if( ndigits > ldp->outexpon )\r
- k = ndigits;\r
-else\r
- k = ldp->outexpon;\r
-\r
-while( *(s-1) == '0' && ((s - outstr) > k))\r
- *(--s) = '\0';\r
-\r
-/* In f format, flush small off-scale values to zero.\r
- Rounding has been taken care of by etoasc. */\r
-if( mode == 3 && ((ndigits + ldp->outexpon) < 0))\r
- {\r
- s = outstr;\r
- *s = '\0';\r
- *decpt = 0;\r
- }\r
-\r
-if( rve )\r
- *rve = s;\r
-return outstr;\r
-}\r
-\r
-static void etoasc(short unsigned int *x, char *string, int ndigits, int outformat, LDPARMS *ldp)\r
-{\r
-long digit;\r
-unsigned short y[NI], t[NI], u[NI], w[NI];\r
-unsigned short *p, *r, *ten;\r
-unsigned short sign;\r
-int i, j, k, expon, rndsav, ndigs;\r
-char *s, *ss;\r
-unsigned short m;\r
-unsigned short *equot = ldp->equot;\r
-\r
-ndigs = ndigits;\r
-rndsav = ldp->rndprc;\r
-#ifdef NANS\r
-if( eisnan(x) )\r
- {\r
- sprintf( string, " NaN " );\r
- expon = 9999;\r
- goto bxit;\r
- }\r
-#endif\r
-ldp->rndprc = NBITS; /* set to full precision */\r
-emov( x, y ); /* retain external format */\r
-if( y[NE-1] & 0x8000 )\r
- {\r
- sign = 0xffff;\r
- y[NE-1] &= 0x7fff;\r
- }\r
-else\r
- {\r
- sign = 0;\r
- }\r
-expon = 0;\r
-ten = &etens[NTEN][0];\r
-emov( eone, t );\r
-/* Test for zero exponent */\r
-if( y[NE-1] == 0 )\r
- {\r
- for( k=0; k<NE-1; k++ )\r
- {\r
- if( y[k] != 0 )\r
- goto tnzro; /* denormalized number */\r
- }\r
- goto isone; /* legal all zeros */\r
- }\r
-tnzro:\r
-\r
-/* Test for infinity.\r
- */\r
-if( y[NE-1] == 0x7fff )\r
- {\r
- if( sign )\r
- sprintf( string, " -Infinity " );\r
- else\r
- sprintf( string, " Infinity " );\r
- expon = 9999;\r
- goto bxit;\r
- }\r
-\r
-/* Test for exponent nonzero but significand denormalized.\r
- * This is an error condition.\r
- */\r
-if( (y[NE-1] != 0) && ((y[NE-2] & 0x8000) == 0) )\r
- {\r
- mtherr( "etoasc", DOMAIN );\r
- sprintf( string, "NaN" );\r
- expon = 9999;\r
- goto bxit;\r
- }\r
-\r
-/* Compare to 1.0 */\r
-i = ecmp( eone, y );\r
-if( i == 0 )\r
- goto isone;\r
-\r
-if( i < 0 )\r
- { /* Number is greater than 1 */\r
-/* Convert significand to an integer and strip trailing decimal zeros. */\r
- emov( y, u );\r
- u[NE-1] = EXONE + NBITS - 1;\r
-\r
- p = &etens[NTEN-4][0];\r
- m = 16;\r
-do\r
- {\r
- ediv( p, u, t, ldp );\r
- efloor( t, w, ldp );\r
- for( j=0; j<NE-1; j++ )\r
- {\r
- if( t[j] != w[j] )\r
- goto noint;\r
- }\r
- emov( t, u );\r
- expon += (int )m;\r
-noint:\r
- p += NE;\r
- m >>= 1;\r
- }\r
-while( m != 0 );\r
-\r
-/* Rescale from integer significand */\r
- u[NE-1] += y[NE-1] - (unsigned int )(EXONE + NBITS - 1);\r
- emov( u, y );\r
-/* Find power of 10 */\r
- emov( eone, t );\r
- m = MAXP;\r
- p = &etens[0][0];\r
- while( ecmp( ten, u ) <= 0 )\r
- {\r
- if( ecmp( p, u ) <= 0 )\r
- {\r
- ediv( p, u, u, ldp );\r
- emul( p, t, t, ldp );\r
- expon += (int )m;\r
- }\r
- m >>= 1;\r
- if( m == 0 )\r
- break;\r
- p += NE;\r
- }\r
- }\r
-else\r
- { /* Number is less than 1.0 */\r
-/* Pad significand with trailing decimal zeros. */\r
- if( y[NE-1] == 0 )\r
- {\r
- while( (y[NE-2] & 0x8000) == 0 )\r
- {\r
- emul( ten, y, y, ldp );\r
- expon -= 1;\r
- }\r
- }\r
- else\r
- {\r
- emovi( y, w );\r
- for( i=0; i<NDEC+1; i++ )\r
- {\r
- if( (w[NI-1] & 0x7) != 0 )\r
- break;\r
-/* multiply by 10 */\r
- emovz( w, u );\r
- eshdn1( u );\r
- eshdn1( u );\r
- eaddm( w, u );\r
- u[1] += 3;\r
- while( u[2] != 0 )\r
- {\r
- eshdn1(u);\r
- u[1] += 1;\r
- }\r
- if( u[NI-1] != 0 )\r
- break;\r
- if( eone[NE-1] <= u[1] )\r
- break;\r
- emovz( u, w );\r
- expon -= 1;\r
- }\r
- emovo( w, y, ldp );\r
- }\r
- k = -MAXP;\r
- p = &emtens[0][0];\r
- r = &etens[0][0];\r
- emov( y, w );\r
- emov( eone, t );\r
- while( ecmp( eone, w ) > 0 )\r
- {\r
- if( ecmp( p, w ) >= 0 )\r
- {\r
- emul( r, w, w, ldp );\r
- emul( r, t, t, ldp );\r
- expon += k;\r
- }\r
- k /= 2;\r
- if( k == 0 )\r
- break;\r
- p += NE;\r
- r += NE;\r
- }\r
- ediv( t, eone, t, ldp );\r
- }\r
-isone:\r
-/* Find the first (leading) digit. */\r
-emovi( t, w );\r
-emovz( w, t );\r
-emovi( y, w );\r
-emovz( w, y );\r
-eiremain( t, y, ldp );\r
-digit = equot[NI-1];\r
-while( (digit == 0) && (ecmp(y,ezero) != 0) )\r
- {\r
- eshup1( y );\r
- emovz( y, u );\r
- eshup1( u );\r
- eshup1( u );\r
- eaddm( u, y );\r
- eiremain( t, y, ldp );\r
- digit = equot[NI-1];\r
- expon -= 1;\r
- }\r
-s = string;\r
-if( sign )\r
- *s++ = '-';\r
-else\r
- *s++ = ' ';\r
-/* Examine number of digits requested by caller. */\r
-if( outformat == 3 )\r
- ndigs += expon;\r
-/*\r
-else if( ndigs < 0 )\r
- ndigs = 0;\r
-*/\r
-if( ndigs > NDEC )\r
- ndigs = NDEC;\r
-if( digit == 10 )\r
- {\r
- *s++ = '1';\r
- *s++ = '.';\r
- if( ndigs > 0 )\r
- {\r
- *s++ = '0';\r
- ndigs -= 1;\r
- }\r
- expon += 1;\r
- if( ndigs < 0 )\r
- {\r
- ss = s;\r
- goto doexp;\r
- }\r
- }\r
-else\r
- {\r
- *s++ = (char )digit + '0';\r
- *s++ = '.';\r
- }\r
-/* Generate digits after the decimal point. */\r
-for( k=0; k<=ndigs; k++ )\r
- {\r
-/* multiply current number by 10, without normalizing */\r
- eshup1( y );\r
- emovz( y, u );\r
- eshup1( u );\r
- eshup1( u );\r
- eaddm( u, y );\r
- eiremain( t, y, ldp );\r
- *s++ = (char )equot[NI-1] + '0';\r
- }\r
-digit = equot[NI-1];\r
---s;\r
-ss = s;\r
-/* round off the ASCII string */\r
-if( digit > 4 )\r
- {\r
-/* Test for critical rounding case in ASCII output. */\r
- if( digit == 5 )\r
- {\r
- emovo( y, t, ldp );\r
- if( ecmp(t,ezero) != 0 )\r
- goto roun; /* round to nearest */\r
- if( (*(s-1) & 1) == 0 )\r
- goto doexp; /* round to even */\r
- }\r
-/* Round up and propagate carry-outs */\r
-roun:\r
- --s;\r
- k = *s & 0x7f;\r
-/* Carry out to most significant digit? */\r
- if( ndigs < 0 )\r
- {\r
- /* This will print like "1E-6". */\r
- *s = '1';\r
- expon += 1;\r
- goto doexp;\r
- }\r
- else if( k == '.' )\r
- {\r
- --s;\r
- k = *s;\r
- k += 1;\r
- *s = (char )k;\r
-/* Most significant digit carries to 10? */\r
- if( k > '9' )\r
- {\r
- expon += 1;\r
- *s = '1';\r
- }\r
- goto doexp;\r
- }\r
-/* Round up and carry out from less significant digits */\r
- k += 1;\r
- *s = (char )k;\r
- if( k > '9' )\r
- {\r
- *s = '0';\r
- goto roun;\r
- }\r
- }\r
-doexp:\r
-#ifdef __GO32__\r
-if( expon >= 0 )\r
- sprintf( ss, "e+%02d", expon );\r
-else\r
- sprintf( ss, "e-%02d", -expon );\r
-#else\r
- sprintf( ss, "E%d", expon );\r
-#endif\r
-bxit:\r
-ldp->rndprc = rndsav;\r
-ldp->outexpon = expon;\r
-}\r
-\r
-\r
-\r
-\r
-/*\r
-; ASCTOQ\r
-; ASCTOQ.MAC LATEST REV: 11 JAN 84\r
-; SLM, 3 JAN 78\r
-;\r
-; Convert ASCII string to quadruple precision floating point\r
-;\r
-; Numeric input is free field decimal number\r
-; with max of 15 digits with or without \r
-; decimal point entered as ASCII from teletype.\r
-; Entering E after the number followed by a second\r
-; number causes the second number to be interpreted\r
-; as a power of 10 to be multiplied by the first number\r
-; (i.e., "scientific" notation).\r
-;\r
-; Usage:\r
-; asctoq( string, q );\r
-*/\r
-\r
-long double _strtold (char *s, char **se)\r
-{\r
- long double x;\r
- LDPARMS rnd;\r
- LDPARMS *ldp = &rnd;\r
- int lenldstr;\r
-\r
- rnd.rlast = -1;\r
- rnd.rndprc = NBITS;\r
-\r
- lenldstr = asctoeg( s, (unsigned short *)&x, LDBL_MANT_DIG, ldp );\r
- if (se)\r
- *se = s + lenldstr;\r
- return x;\r
-}\r
-\r
-\r
-\r
-static int\r
-asctoeg(char *ss, short unsigned int *y, int oprec, LDPARMS *ldp)\r
-{\r
-unsigned short yy[NI], xt[NI], tt[NI];\r
-int esign, decflg, sgnflg, nexp, exp, prec, lost;\r
-int k, trail, c, rndsav;\r
-long lexp;\r
-unsigned short nsign, *p;\r
-char *sp, *s, *lstr;\r
-int lenldstr;\r
-\r
-/* Copy the input string. */\r
-c = strlen (ss) + 2;\r
-lstr = (char *) alloca (c);\r
-s = ss;\r
-lenldstr = 0;\r
-while( *s == ' ' ) /* skip leading spaces */\r
- {\r
- ++s;\r
- ++lenldstr;\r
- }\r
-sp = lstr;\r
-for( k=0; k<c; k++ )\r
- {\r
- if( (*sp++ = *s++) == '\0' )\r
- break;\r
- }\r
-*sp = '\0';\r
-s = lstr;\r
-\r
-rndsav = ldp->rndprc;\r
-ldp->rndprc = NBITS; /* Set to full precision */\r
-lost = 0;\r
-nsign = 0;\r
-decflg = 0;\r
-sgnflg = 0;\r
-nexp = 0;\r
-exp = 0;\r
-prec = 0;\r
-ecleaz( yy );\r
-trail = 0;\r
-\r
-nxtcom:\r
-k = *s - '0';\r
-if( (k >= 0) && (k <= 9) )\r
- {\r
-/* Ignore leading zeros */\r
- if( (prec == 0) && (decflg == 0) && (k == 0) )\r
- goto donchr;\r
-/* Identify and strip trailing zeros after the decimal point. */\r
- if( (trail == 0) && (decflg != 0) )\r
- {\r
- sp = s;\r
- while( (*sp >= '0') && (*sp <= '9') )\r
- ++sp;\r
-/* Check for syntax error */\r
- c = *sp & 0x7f;\r
- if( (c != 'e') && (c != 'E') && (c != '\0')\r
- && (c != '\n') && (c != '\r') && (c != ' ')\r
- && (c != ',') )\r
- goto error;\r
- --sp;\r
- while( *sp == '0' )\r
- *sp-- = 'z';\r
- trail = 1;\r
- if( *s == 'z' )\r
- goto donchr;\r
- }\r
-/* If enough digits were given to more than fill up the yy register,\r
- * continuing until overflow into the high guard word yy[2]\r
- * guarantees that there will be a roundoff bit at the top\r
- * of the low guard word after normalization.\r
- */\r
- if( yy[2] == 0 )\r
- {\r
- if( decflg )\r
- nexp += 1; /* count digits after decimal point */\r
- eshup1( yy ); /* multiply current number by 10 */\r
- emovz( yy, xt );\r
- eshup1( xt );\r
- eshup1( xt );\r
- eaddm( xt, yy );\r
- ecleaz( xt );\r
- xt[NI-2] = (unsigned short )k;\r
- eaddm( xt, yy );\r
- }\r
- else\r
- {\r
- /* Mark any lost non-zero digit. */\r
- lost |= k;\r
- /* Count lost digits before the decimal point. */\r
- if (decflg == 0)\r
- nexp -= 1;\r
- }\r
- prec += 1;\r
- goto donchr;\r
- }\r
-\r
-switch( *s )\r
- {\r
- case 'z':\r
- break;\r
- case 'E':\r
- case 'e':\r
- goto expnt;\r
- case '.': /* decimal point */\r
- if( decflg )\r
- goto error;\r
- ++decflg;\r
- break;\r
- case '-':\r
- nsign = 0xffff;\r
- if( sgnflg )\r
- goto error;\r
- ++sgnflg;\r
- break;\r
- case '+':\r
- if( sgnflg )\r
- goto error;\r
- ++sgnflg;\r
- break;\r
- case ',':\r
- case ' ':\r
- case '\0':\r
- case '\n':\r
- case '\r':\r
- goto daldone;\r
- case 'i':\r
- case 'I':\r
- goto infinite;\r
- default:\r
- error:\r
-#ifdef NANS\r
- enan( yy, NI*16 );\r
-#else\r
- mtherr( "asctoe", DOMAIN );\r
- ecleaz(yy);\r
-#endif\r
- goto aexit;\r
- }\r
-donchr:\r
-++s;\r
-goto nxtcom;\r
-\r
-/* Exponent interpretation */\r
-expnt:\r
-\r
-esign = 1;\r
-exp = 0;\r
-++s;\r
-/* check for + or - */\r
-if( *s == '-' )\r
- {\r
- esign = -1;\r
- ++s;\r
- }\r
-if( *s == '+' )\r
- ++s;\r
-while( (*s >= '0') && (*s <= '9') )\r
- {\r
- exp *= 10;\r
- exp += *s++ - '0';\r
- if (exp > 4977)\r
- {\r
- if (esign < 0)\r
- goto zero;\r
- else\r
- goto infinite;\r
- }\r
- }\r
-if( esign < 0 )\r
- exp = -exp;\r
-if( exp > 4932 )\r
- {\r
-infinite:\r
- ecleaz(yy);\r
- yy[E] = 0x7fff; /* infinity */\r
- goto aexit;\r
- }\r
-if( exp < -4977 )\r
- {\r
-zero:\r
- ecleaz(yy);\r
- goto aexit;\r
- }\r
-\r
-daldone:\r
-nexp = exp - nexp;\r
-/* Pad trailing zeros to minimize power of 10, per IEEE spec. */\r
-while( (nexp > 0) && (yy[2] == 0) )\r
- {\r
- emovz( yy, xt );\r
- eshup1( xt );\r
- eshup1( xt );\r
- eaddm( yy, xt );\r
- eshup1( xt );\r
- if( xt[2] != 0 )\r
- break;\r
- nexp -= 1;\r
- emovz( xt, yy );\r
- }\r
-if( (k = enormlz(yy)) > NBITS )\r
- {\r
- ecleaz(yy);\r
- goto aexit;\r
- }\r
-lexp = (EXONE - 1 + NBITS) - k;\r
-emdnorm( yy, lost, 0, lexp, 64, ldp );\r
-/* convert to external format */\r
-\r
-\r
-/* Multiply by 10**nexp. If precision is 64 bits,\r
- * the maximum relative error incurred in forming 10**n\r
- * for 0 <= n <= 324 is 8.2e-20, at 10**180.\r
- * For 0 <= n <= 999, the peak relative error is 1.4e-19 at 10**947.\r
- * For 0 >= n >= -999, it is -1.55e-19 at 10**-435.\r
- */\r
-lexp = yy[E];\r
-if( nexp == 0 )\r
- {\r
- k = 0;\r
- goto expdon;\r
- }\r
-esign = 1;\r
-if( nexp < 0 )\r
- {\r
- nexp = -nexp;\r
- esign = -1;\r
- if( nexp > 4096 )\r
- { /* Punt. Can't handle this without 2 divides. */\r
- emovi( etens[0], tt );\r
- lexp -= tt[E];\r
- k = edivm( tt, yy, ldp );\r
- lexp += EXONE;\r
- nexp -= 4096;\r
- }\r
- }\r
-p = &etens[NTEN][0];\r
-emov( eone, xt );\r
-exp = 1;\r
-do\r
- {\r
- if( exp & nexp )\r
- emul( p, xt, xt, ldp );\r
- p -= NE;\r
- exp = exp + exp;\r
- }\r
-while( exp <= MAXP );\r
-\r
-emovi( xt, tt );\r
-if( esign < 0 )\r
- {\r
- lexp -= tt[E];\r
- k = edivm( tt, yy, ldp );\r
- lexp += EXONE;\r
- }\r
-else\r
- {\r
- lexp += tt[E];\r
- k = emulm( tt, yy, ldp );\r
- lexp -= EXONE - 1;\r
- }\r
-\r
-expdon:\r
-\r
-/* Round and convert directly to the destination type */\r
-if( oprec == 53 )\r
- lexp -= EXONE - 0x3ff;\r
-else if( oprec == 24 )\r
- lexp -= EXONE - 0177;\r
-#ifdef DEC\r
-else if( oprec == 56 )\r
- lexp -= EXONE - 0201;\r
-#endif\r
-ldp->rndprc = oprec;\r
-emdnorm( yy, k, 0, lexp, 64, ldp );\r
-\r
-aexit:\r
-\r
-ldp->rndprc = rndsav;\r
-yy[0] = nsign;\r
-switch( oprec )\r
- {\r
-#ifdef DEC\r
- case 56:\r
- todec( yy, y ); /* see etodec.c */\r
- break;\r
-#endif\r
-#if LDBL_MANT_DIG == 53\r
- case 53:\r
- toe53( yy, y );\r
- break;\r
-#elif LDBL_MANT_DIG == 24\r
- case 24:\r
- toe24( yy, y );\r
- break;\r
-#elif LDBL_MANT_DIG == 64\r
- case 64:\r
- toe64( yy, y );\r
- break;\r
-#elif LDBL_MANT_DIG == 113\r
- case 113:\r
- toe113( yy, y );\r
- break;\r
-#else\r
- case NBITS:\r
- emovo( yy, y, ldp );\r
- break;\r
-#endif\r
- }\r
-lenldstr += s - lstr;\r
-return lenldstr;\r
-}\r
-\r
-\r
- \r
-/* y = largest integer not greater than x\r
- * (truncated toward minus infinity)\r
- *\r
- * unsigned short x[NE], y[NE]\r
- * LDPARMS *ldp\r
- *\r
- * efloor( x, y, ldp );\r
- */\r
-static unsigned short bmask[] = {\r
-0xffff,\r
-0xfffe,\r
-0xfffc,\r
-0xfff8,\r
-0xfff0,\r
-0xffe0,\r
-0xffc0,\r
-0xff80,\r
-0xff00,\r
-0xfe00,\r
-0xfc00,\r
-0xf800,\r
-0xf000,\r
-0xe000,\r
-0xc000,\r
-0x8000,\r
-0x0000,\r
-};\r
-\r
-static void efloor(short unsigned int *x, short unsigned int *y, LDPARMS *ldp)\r
-{\r
-register unsigned short *p;\r
-int e, expon, i;\r
-unsigned short f[NE];\r
-\r
-emov( x, f ); /* leave in external format */\r
-expon = (int )f[NE-1];\r
-e = (expon & 0x7fff) - (EXONE - 1);\r
-if( e <= 0 )\r
- {\r
- eclear(y);\r
- goto isitneg;\r
- }\r
-/* number of bits to clear out */\r
-e = NBITS - e;\r
-emov( f, y );\r
-if( e <= 0 )\r
- return;\r
-\r
-p = &y[0];\r
-while( e >= 16 )\r
- {\r
- *p++ = 0;\r
- e -= 16;\r
- }\r
-/* clear the remaining bits */\r
-*p &= bmask[e];\r
-/* truncate negatives toward minus infinity */\r
-isitneg:\r
-\r
-if( (unsigned short )expon & (unsigned short )0x8000 )\r
- {\r
- for( i=0; i<NE-1; i++ )\r
- {\r
- if( f[i] != y[i] )\r
- {\r
- esub( eone, y, y, ldp );\r
- break;\r
- }\r
- }\r
- }\r
-}\r
-\r
-\r
-\r
-static void eiremain(short unsigned int *den, short unsigned int *num, LDPARMS *ldp)\r
-{\r
-long ld, ln;\r
-unsigned short j;\r
- unsigned short *equot = ldp->equot;\r
-\r
-ld = den[E];\r
-ld -= enormlz( den );\r
-ln = num[E];\r
-ln -= enormlz( num );\r
-ecleaz( equot );\r
-while( ln >= ld )\r
- {\r
- if( ecmpm(den,num) <= 0 )\r
- {\r
- esubm(den, num);\r
- j = 1;\r
- }\r
- else\r
- {\r
- j = 0;\r
- }\r
- eshup1(equot);\r
- equot[NI-1] |= j;\r
- eshup1(num);\r
- ln -= 1;\r
- }\r
-emdnorm( num, 0, 0, ln, 0, ldp );\r
-}\r
-\r
-/* NaN bit patterns\r
- */\r
-#ifdef MIEEE\r
-static unsigned short nan113[8] = {\r
- 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};\r
-static unsigned short nan64[6] = {0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};\r
-static unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff};\r
-static unsigned short nan24[2] = {0x7fff, 0xffff};\r
-#else /* !MIEEE */\r
-static unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0x8000, 0x7fff};\r
-static unsigned short nan64[6] = {0, 0, 0, 0, 0xc000, 0x7fff};\r
-static unsigned short nan53[4] = {0, 0, 0, 0x7ff8};\r
-static unsigned short nan24[2] = {0, 0x7fc0};\r
-#endif /* !MIEEE */\r
-\r
-\r
-static void enan (short unsigned int *nan, int size)\r
-{\r
-int i, n;\r
-unsigned short *p;\r
-\r
-switch( size )\r
- {\r
-#ifndef DEC\r
- case 113:\r
- n = 8;\r
- p = nan113;\r
- break;\r
-\r
- case 64:\r
- n = 6;\r
- p = nan64;\r
- break;\r
-\r
- case 53:\r
- n = 4;\r
- p = nan53;\r
- break;\r
-\r
- case 24:\r
- n = 2;\r
- p = nan24;\r
- break;\r
-\r
- case NBITS:\r
- for( i=0; i<NE-2; i++ )\r
- *nan++ = 0;\r
- *nan++ = 0xc000;\r
- *nan++ = 0x7fff;\r
- return;\r
-\r
- case NI*16:\r
- *nan++ = 0;\r
- *nan++ = 0x7fff;\r
- *nan++ = 0;\r
- *nan++ = 0xc000;\r
- for( i=4; i<NI; i++ )\r
- *nan++ = 0;\r
- return;\r
-#endif\r
- default:\r
- mtherr( "enan", DOMAIN );\r
- return;\r
- }\r
-for (i=0; i < n; i++)\r
- *nan++ = *p++;\r
-}\r
-\r
-\r
-\r
-\r
+
+ /* Extended precision arithmetic functions for long double I/O.
+ * This program has been placed in the public domain.
+ */
+
+#include <_ansi.h>
+#include <reent.h>
+#include <string.h>
+#include <stdlib.h>
+#include "mprec.h"
+
+/* These are the externally visible entries. */
+/* linux name: long double _IO_strtold (char *, char **); */
+long double _strtold (char *, char **);
+char * _ldtoa_r (struct _reent *, long double, int, int, int *, int *, char **);
+#if 0
+void _IO_ldtostr(long double *, char *, int, int, char);
+#endif
+
+ /* 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)
+
+/* Control structure for long doublue conversion including rounding precision values.
+ * rndprc can be set to 80 (if NE=6), 64, 56, 53, or 24 bits.
+ */
+typedef struct
+{
+ int rlast;
+ int rndprc;
+ int rw;
+ int re;
+ int outexpon;
+ unsigned short rmsk;
+ unsigned short rmbit;
+ unsigned short rebit;
+ unsigned short rbit[NI];
+ unsigned short equot[NI];
+} LDPARMS;
+
+static void esub(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp);
+static void emul(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp);
+static void ediv(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp);
+static int ecmp(short unsigned int *a, short unsigned int *b);
+static int enormlz(short unsigned int *x);
+static int eshift(short unsigned int *x, int sc);
+static void eshup1(register short unsigned int *x);
+static void eshup8(register short unsigned int *x);
+static void eshup6(register short unsigned int *x);
+static void eshdn1(register short unsigned int *x);
+static void eshdn8(register short unsigned int *x);
+static void eshdn6(register short unsigned int *x);
+static void eneg(short unsigned int *x);
+static void emov(register short unsigned int *a, register short unsigned int *b);
+static void eclear(register short unsigned int *x);
+static void einfin(register short unsigned int *x, register LDPARMS *ldp);
+static void efloor(short unsigned int *x, short unsigned int *y, LDPARMS *ldp);
+static void etoasc(short unsigned int *x, char *string, int ndigs, int outformat, LDPARMS *ldp);
+
+#if LDBL_MANT_DIG == 24
+static void e24toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);
+#elif LDBL_MANT_DIG == 53
+static void e53toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);
+#elif LDBL_MANT_DIG == 64
+static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);
+#else
+static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp);
+#endif
+
+/* econst.c */
+/* e type constants used by high precision check routines */
+
+#if NE == 10
+/* 0.0 */
+static unsigned short ezero[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,};
+
+/* 1.0E0 */
+static unsigned short eone[NE] =
+ {0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x8000, 0x3fff,};
+
+#else
+
+/* 0.0 */
+static unsigned short ezero[NE] = {
+0, 0000000,0000000,0000000,0000000,0000000,};
+/* 1.0E0 */
+static unsigned short eone[NE] = {
+0, 0000000,0000000,0000000,0100000,0x3fff,};
+
+#endif
+
+/* Debugging routine for displaying errors */
+#ifdef DEBUG
+/* 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"
+};
+#define mtherr(name, code) printf( "\n%s %s error\n", name, ermsg[code] );
+#else
+#define mtherr(name, code)
+#endif
+
+/* 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, ldp ) ASCII string to specified precision
+ * e24toe( &f, e, ldp ) IEEE single precision to e type
+ * e53toe( &d, e, ldp ) IEEE double precision to e type
+ * e64toe( &d, e, ldp ) IEEE long double precision to e type
+ * e113toe( &d, e, ldp ) 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, ldp ) c = b / a
+ * efloor( a, b, ldp ) 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, ldp ) 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, ldp ) c = b * a
+ * eneg(e) e = -e
+ * eround( a, b ) b = nearest integer value to a
+ * esub( a, b, c, ldp ) 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,fmt,ldp)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, ldp ) divide significands, bi = bi / ai
+ * emdnorm(ai,l,s,exp,ldp) normalize and round off
+ * emovi( a, ai ) convert external a to internal ai
+ * emovo( ai, a, ldp ) convert internal ai to external a
+ * emovz( ai, bi ) bi = ai, low guard word of bi = 0
+ * emulm( ai, bi, ldp ) 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
+ * 6 Dec 86 C language version
+ * 30 Aug 88 100 digit version, improved rounding
+ * 15 May 92 80-bit long double support
+ * 22 Nov 00 Revised to fit into newlib by Jeff Johnston <jjohnstn@redhat.com>
+ *
+ * Author: S. L. Moshier.
+ *
+ * Copyright (c) 1984,2000 S.L. Moshier
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ *
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION
+ * OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
+ * SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ */
+
+#include <stdio.h>
+/* #include "\usr\include\stdio.h" */
+/*#include "ehead.h"*/
+/*#include "mconf.h"*/
+/* 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 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.
+ *
+ * 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, the symbol UNK is defined.
+ *
+ * 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.
+ *
+ * For ANSI C compatibility, define ANSIC equal to 1. Currently
+ * this affects only the atan2() function and others that use it.
+ */
+
+/* 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
+
+typedef struct
+ {
+ double r;
+ double i;
+ }cmplx;
+
+/* Type of computer arithmetic */
+
+#ifndef DEC
+#ifdef __IEEE_LITTLE_ENDIAN
+#define IBMPC 1
+#else /* !__IEEE_LITTLE_ENDIAN */
+#define MIEEE 1
+#endif /* !__IEEE_LITTLE_ENDIAN */
+#endif /* !DEC */
+
+/* Define 1 for ANSI C atan2() function
+ * See atan.c and clog.c.
+ */
+#define ANSIC 1
+
+/*define VOLATILE volatile*/
+#define VOLATILE
+
+#define NANS
+#define INFINITY
+
+/* NaN's require infinity support. */
+#ifdef NANS
+#ifndef INFINITY
+#define INFINITY
+#endif
+#endif
+
+/* This handles 64-bit long ints. */
+#define LONGBITS (8 * sizeof(long))
+
+
+static void eaddm(short unsigned int *x, short unsigned int *y);
+static void esubm(short unsigned int *x, short unsigned int *y);
+static void emdnorm(short unsigned int *s, int lost, int subflg, long int exp, int rcntrl, LDPARMS *ldp);
+static int asctoeg(char *ss, short unsigned int *y, int oprec, LDPARMS *ldp);
+static void enan(short unsigned int *nan, int size);
+#if LDBL_MANT_DIG == 24
+static void toe24(short unsigned int *x, short unsigned int *y);
+#elif LDBL_MANT_DIG == 53
+static void toe53(short unsigned int *x, short unsigned int *y);
+#elif LDBL_MANT_DIG == 64
+static void toe64(short unsigned int *a, short unsigned int *b);
+#else
+static void toe113(short unsigned int *a, short unsigned int *b);
+#endif
+static void eiremain(short unsigned int *den, short unsigned int *num, LDPARMS *ldp);
+static int ecmpm(register short unsigned int *a, register short unsigned int *b);
+static int edivm(short unsigned int *den, short unsigned int *num, LDPARMS *ldp);
+static int emulm(short unsigned int *a, short unsigned int *b, LDPARMS *ldp);
+static int eisneg(short unsigned int *x);
+static int eisinf(short unsigned int *x);
+static void emovi(short unsigned int *a, short unsigned int *b);
+static void emovo(short unsigned int *a, short unsigned int *b, LDPARMS *ldp);
+static void emovz(register short unsigned int *a, register short unsigned int *b);
+static void ecleaz(register short unsigned int *xi);
+static void eadd1(short unsigned int *a, short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp);
+static int eisnan(short unsigned int *x);
+static int eiisnan(short unsigned int *x);
+
+#ifdef DEC
+static void etodec(), todec(), dectoe();
+#endif
+
+/*
+; Clear out entire external format number.
+;
+; unsigned short x[];
+; eclear( x );
+*/
+
+static void eclear(register short unsigned int *x)
+{
+register int i;
+
+for( i=0; i<NE; i++ )
+ *x++ = 0;
+}
+
+
+
+/* Move external format number from a to b.
+ *
+ * emov( a, b );
+ */
+
+static void emov(register short unsigned int *a, register short unsigned int *b)
+{
+register int i;
+
+for( i=0; i<NE; i++ )
+ *b++ = *a++;
+}
+
+
+/*
+; Negate external format number
+;
+; unsigned short x[NE];
+; eneg( x );
+*/
+
+static void eneg(short unsigned int *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.
+ */
+static int eisneg(short unsigned int *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.
+ */
+static int eisinf(short unsigned int *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.
+ */
+static int eisnan(short unsigned int *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.
+*/
+
+static void einfin(register short unsigned int *x, register LDPARMS *ldp)
+{
+register int i;
+
+#ifdef INFINITY
+for( i=0; i<NE-1; i++ )
+ *x++ = 0;
+*x |= 32767;
+ldp = ldp;
+#else
+for( i=0; i<NE-1; i++ )
+ *x++ = 0xffff;
+*x |= 32766;
+if( ldp->rndprc < NBITS )
+ {
+ if (ldp->rndprc == 113)
+ {
+ *(x - 9) = 0;
+ *(x - 8) = 0;
+ }
+ if( ldp->rndprc == 64 )
+ {
+ *(x-5) = 0;
+ }
+ if( ldp->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.
+ */
+static void emovi(short unsigned int *a, short unsigned int *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.
+ */
+static void emovo(short unsigned int *a, short unsigned int *b, LDPARMS *ldp)
+{
+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, ldp);
+ return;
+ }
+#endif
+/* skip over guard word */
+++p;
+/* move the significand */
+for( i=0; i<NE-1; i++ )
+ *q-- = *p++;
+}
+
+
+/* Clear out internal format number.
+ */
+
+static void ecleaz(register short unsigned int *xi)
+{
+register int i;
+
+for( i=0; i<NI; i++ )
+ *xi++ = 0;
+}
+
+/* same, but don't touch the sign. */
+
+static void ecleazs(register short unsigned int *xi)
+{
+register int i;
+
+++xi;
+for(i=0; i<NI-1; i++)
+ *xi++ = 0;
+}
+
+
+
+
+/* Move internal format number from a to b.
+ */
+static void emovz(register short unsigned int *a, register short unsigned int *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.
+ */
+
+static int eiisnan (short unsigned int *x)
+{
+int i;
+
+if( (x[E] & 0x7fff) == 0x7fff )
+ {
+ for( i=M+1; i<NI; i++ )
+ {
+ if( x[i] != 0 )
+ return(1);
+ }
+ }
+return(0);
+}
+
+#if LDBL_MANT_DIG == 64
+
+/* 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 /* LDBL_MANT_DIG == 64 */
+
+/*
+; 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
+*/
+static int ecmpm(register short unsigned int *a, register short unsigned int *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
+*/
+
+static void eshdn1(register short unsigned int *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
+*/
+
+static void eshup1(register short unsigned int *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
+*/
+
+static void eshdn8(register short unsigned int *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
+*/
+
+static void eshup8(register short unsigned int *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
+*/
+
+static void eshup6(register short unsigned int *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
+*/
+
+static void eshdn6(register short unsigned int *x)
+{
+int i;
+register unsigned short *p;
+
+x += NI-1;
+p = x + 1;
+
+for( i=M; i<NI-1; i++ )
+ *(--p) = *(--x);
+
+*(--p) = 0;
+}
+\f
+/*
+; Add significands
+; x + y replaces y
+*/
+
+static void eaddm(short unsigned int *x, short unsigned int *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
+*/
+
+static void esubm(short unsigned int *x, short unsigned int *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 */
+
+
+/* Multiply significand of e-type number b
+by 16-bit quantity a, e-type result to c. */
+
+static void m16m(short unsigned int a, short unsigned int *b, short unsigned int *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. */
+
+
+static int edivm(short unsigned int *den, short unsigned int *num, LDPARMS *ldp)
+{
+int i;
+register unsigned short *p;
+unsigned long tnum;
+unsigned short j, tdenm, tquot;
+unsigned short tprod[NI+1];
+unsigned short *equot = ldp->equot;
+
+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 * 0xffffUL) < 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 */
+static int emulm(short unsigned int *a, short unsigned int *b, LDPARMS *ldp)
+{
+unsigned short *p, *q;
+unsigned short pprod[NI];
+unsigned short j;
+int i;
+unsigned short *equot = ldp->equot;
+
+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 );
+}
+
+
+/*
+static void eshow(str, x)
+char *str;
+unsigned short *x;
+{
+int i;
+
+printf( "%s ", str );
+for( i=0; i<NI; i++ )
+ printf( "%04x ", *x++ );
+printf( "\n" );
+}
+*/
+
+
+/*
+ * 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 void emdnorm(short unsigned int *s, int lost, int subflg, long int exp, int rcntrl, LDPARMS *ldp)
+{
+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( ldp->rndprc != ldp->rlast )
+ {
+ ecleaz( ldp->rbit );
+ switch( ldp->rndprc )
+ {
+ default:
+ case NBITS:
+ ldp->rw = NI-1; /* low guard word */
+ ldp->rmsk = 0xffff;
+ ldp->rmbit = 0x8000;
+ ldp->rebit = 1;
+ ldp->re = ldp->rw - 1;
+ break;
+ case 113:
+ ldp->rw = 10;
+ ldp->rmsk = 0x7fff;
+ ldp->rmbit = 0x4000;
+ ldp->rebit = 0x8000;
+ ldp->re = ldp->rw;
+ break;
+ case 64:
+ ldp->rw = 7;
+ ldp->rmsk = 0xffff;
+ ldp->rmbit = 0x8000;
+ ldp->rebit = 1;
+ ldp->re = ldp->rw-1;
+ break;
+/* For DEC arithmetic */
+ case 56:
+ ldp->rw = 6;
+ ldp->rmsk = 0xff;
+ ldp->rmbit = 0x80;
+ ldp->rebit = 0x100;
+ ldp->re = ldp->rw;
+ break;
+ case 53:
+ ldp->rw = 6;
+ ldp->rmsk = 0x7ff;
+ ldp->rmbit = 0x0400;
+ ldp->rebit = 0x800;
+ ldp->re = ldp->rw;
+ break;
+ case 24:
+ ldp->rw = 4;
+ ldp->rmsk = 0xff;
+ ldp->rmbit = 0x80;
+ ldp->rebit = 0x100;
+ ldp->re = ldp->rw;
+ break;
+ }
+ ldp->rbit[ldp->re] = ldp->rebit;
+ ldp->rlast = ldp->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.
+ */
+#if IBMPC
+if( (exp <= 0) && (ldp->rndprc != NBITS) )
+#else
+if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->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[ldp->rw] & ldp->rmsk;
+if( ldp->rndprc < NBITS )
+ {
+ i = ldp->rw + 1;
+ while( i < NI )
+ {
+ if( s[i] )
+ r |= 1;
+ s[i] = 0;
+ ++i;
+ }
+ }
+s[ldp->rw] &= ~ldp->rmsk;
+if( (r & ldp->rmbit) != 0 )
+ {
+ if( r == ldp->rmbit )
+ {
+ if( lost == 0 )
+ { /* round to even */
+ if( (s[ldp->re] & ldp->rebit) == 0 )
+ goto mddone;
+ }
+ else
+ {
+ if( subflg != 0 )
+ goto mddone;
+ }
+ }
+ eaddm( ldp->rbit, s );
+ }
+mddone:
+#if IBMPC
+if( (exp <= 0) && (ldp->rndprc != NBITS) )
+#else
+if( (exp <= 0) && (ldp->rndprc != 64) && (ldp->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( (ldp->rndprc < 64) || (ldp->rndprc == 113) )
+ {
+ s[ldp->rw] &= ~ldp->rmsk;
+ if( ldp->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];
+; LDPARMS *ldp;
+; esub( a, b, c, ldp ); c = b - a
+*/
+
+static void esub(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp)
+{
+
+#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
+eadd1( a, b, c, 1, ldp );
+}
+
+
+
+static void eadd1(short unsigned int *a, short unsigned int *b, short unsigned int *c, int subflg, LDPARMS *ldp)
+{
+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 )
+ {
+/* This could overflow, but let emovo take care of that. */
+ ltb += 1;
+ 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, ldp );
+
+done:
+emovo( bi, c, ldp );
+}
+
+
+
+/*
+; Divide.
+;
+; unsigned short a[NE], b[NE], c[NE];
+; LDPARMS *ldp;
+; ediv( a, b, c, ldp ); c = b / a
+*/
+static void ediv(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp)
+{
+unsigned short ai[NI], bi[NI];
+int i;
+long lt, lta, ltb;
+
+#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) )
+ {
+ if( eisneg(a) ^ eisneg(b) )
+ *(c+(NE-1)) = 0x8000;
+ else
+ *(c+(NE-1)) = 0;
+ einfin(c, ldp);
+ return;
+ }
+if( eisinf(a) )
+ {
+ eclear(c);
+ return;
+ }
+#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);
+ return;
+ }
+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;
+ }
+ }
+ if( ai[0] == bi[0] )
+ *(c+(NE-1)) = 0;
+ else
+ *(c+(NE-1)) = 0x8000;
+ einfin(c, ldp);
+ mtherr( "ediv", SING );
+ return;
+ }
+dnzro2:
+
+i = edivm( ai, bi, ldp );
+/* calculate exponent */
+lt = ltb - lta + EXONE;
+emdnorm( bi, i, 0, lt, 64, ldp );
+/* set the sign */
+if( ai[0] == bi[0] )
+ bi[0] = 0;
+else
+ bi[0] = 0Xffff;
+emovo( bi, c, ldp );
+}
+
+
+
+/*
+; Multiply.
+;
+; unsigned short a[NE], b[NE], c[NE];
+; LDPARMS *ldp
+; emul( a, b, c, ldp ); c = b * a
+*/
+static void emul(short unsigned int *a, short unsigned int *b, short unsigned int *c, LDPARMS *ldp)
+{
+unsigned short ai[NI], bi[NI];
+int i, j;
+long lt, lta, ltb;
+
+#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) )
+ {
+ if( eisneg(a) ^ eisneg(b) )
+ *(c+(NE-1)) = 0x8000;
+ else
+ *(c+(NE-1)) = 0;
+ einfin(c, ldp);
+ return;
+ }
+#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);
+ return;
+ }
+mnzer1:
+
+if( bi[E] == 0 )
+ {
+ for( i=1; i<NI-1; i++ )
+ {
+ if( bi[i] != 0 )
+ {
+ ltb -= enormlz( bi );
+ goto mnzer2;
+ }
+ }
+ eclear(c);
+ return;
+ }
+mnzer2:
+
+/* Multiply significands */
+j = emulm( ai, bi, ldp );
+/* calculate exponent */
+lt = lta + ltb - (EXONE - 1);
+emdnorm( bi, j, 0, lt, 64, ldp );
+/* calculate sign of product */
+if( ai[0] == bi[0] )
+ bi[0] = 0;
+else
+ bi[0] = 0xffff;
+emovo( bi, c, ldp );
+}
+
+
+
+#if LDBL_MANT_DIG > 64
+static void e113toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp)
+{
+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 /* !IBMPC */
+ for( i=1; i<8; i++ )
+ {
+ if( pe[i] != 0 )
+ {
+ enan( y, NBITS );
+ return;
+ }
+ }
+#endif /* !IBMPC */
+#endif /* NANS */
+ eclear( y );
+ einfin( y, ldp );
+ 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);
+#else /* IBMPC */
+++e;
+for( i=0; i<7; i++ )
+ *p++ = *e++;
+#endif /* IBMPC */
+/* 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,ldp);
+}
+
+/* move out internal format to ieee long double */
+static void toe113(short unsigned int *a, short unsigned int *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
+}
+#endif /* LDBL_MANT_DIG > 64 */
+
+
+#if LDBL_MANT_DIG == 64
+static void e64toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp)
+{
+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; /* MIEEE skips over 2nd short */
+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,ldp);
+ return;
+ }
+#endif
+#ifdef INFINITY
+/* Point to the exponent field. */
+p = &yy[NE-1];
+if( *p == 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;
+ }
+ }
+#endif
+#ifdef MIEEE
+ for( i=2; i<=5; i++ )
+ {
+ if( pe[i] != 0 )
+ {
+ enan( y, NBITS );
+ return;
+ }
+ }
+#endif
+#endif /* NANS */
+ eclear( y );
+ einfin( y, ldp );
+ if( *p & 0x8000 )
+ eneg(y);
+ return;
+ }
+#endif /* INFINITY */
+p = yy;
+q = y;
+for( i=0; i<NE; i++ )
+ *q++ = *p++;
+}
+
+/* move out internal format to ieee long double */
+static void toe64(short unsigned int *a, short unsigned int *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 */
+/* NOTE: Intel data type is 96 bits wide, clear the last word here. */
+*(q+1)= 0;
+#endif
+
+/* combine sign and exponent */
+i = *p++;
+#ifdef MIEEE
+if( i )
+ *q++ = *p++ | 0x8000;
+else
+ *q++ = *p++;
+*q++ = 0; /* leave 2nd short blank */
+#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
+#ifdef IBMPC
+if (eiisinf (a))
+ {
+ /* Intel long double infinity. */
+ *q-- = 0x8000;
+ *q-- = 0;
+ *q-- = 0;
+ *q = 0;
+ return;
+ }
+#endif /* IBMPC */
+#endif /* INFINITY */
+for( i=0; i<4; i++ )
+ *q-- = *p++;
+#endif
+}
+
+#endif /* LDBL_MANT_DIG == 64 */
+
+#if LDBL_MANT_DIG == 53
+/*
+; Convert IEEE double precision to e type
+; double d;
+; unsigned short x[N+2];
+; e53toe( &d, x );
+*/
+static void e53toe(short unsigned int *pe, short unsigned int *y, LDPARMS *ldp)
+{
+#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
+#ifdef DEC
+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 /* !IBMPC */
+ if( ((pe[0] & 0xf) != 0) || (pe[1] != 0)
+ || (pe[2] != 0) || (pe[3] != 0) )
+ {
+ enan( y, NBITS );
+ return;
+ }
+#endif /* !IBMPC */
+#endif /* NANS */
+ eclear( y );
+ einfin( y, ldp );
+ 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);
+#else /* !IBMPC */
+++e;
+*p++ = *e++;
+*p++ = *e++;
+*p++ = *e++;
+#endif /* !IBMPC */
+(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, ldp );
+#endif /* !DEC */
+}
+
+/*
+; e type to IEEE double precision
+; double d;
+; unsigned short x[NE];
+; etoe53( x, &d );
+*/
+
+#ifdef DEC
+
+static 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
+
+static void toe53(short unsigned int *x, short unsigned int *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
+#ifdef DEC
+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;
+#else /* !IBMPC */
+ ++y;
+ *y++ = 0;
+ *y++ = 0;
+ *y++ = 0;
+#endif /* IBMPC */
+#else /* !INFINITY */
+ *y |= (unsigned short )0x7fef;
+#ifdef IBMPC
+ *(--y) = 0xffff;
+ *(--y) = 0xffff;
+ *(--y) = 0xffff;
+#else /* !IBMPC */
+ ++y;
+ *y++ = 0xffff;
+ *y++ = 0xffff;
+ *y++ = 0xffff;
+#endif
+#endif /* !INFINITY */
+ 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;
+#else /* !IBMPC */
+++y;
+*y++ = *p++;
+*y++ = *p++;
+*y++ = *p++;
+#endif /* !IBMPC */
+}
+
+#endif /* not DEC */
+#endif /* LDBL_MANT_DIG == 53 */
+
+#if LDBL_MANT_DIG == 24
+/*
+; Convert IEEE single precision to e type
+; float d;
+; unsigned short x[N+2];
+; dtox( &d, x );
+*/
+void e24toe( short unsigned int *pe, short unsigned int *y, LDPARMS *ldp )
+{
+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 /* !MIEEE */
+ if( ((pe[1] & 0x7f) != 0) || (pe[0] != 0) )
+ {
+ enan( y, NBITS );
+ return;
+ }
+#endif /* !MIEEE */
+#endif /* NANS */
+ eclear( y );
+ einfin( y, ldp );
+ 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, ldp );
+}
+
+static void toe24(short unsigned int *x, short unsigned int *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 /* !INFINITY */
+ *y |= (unsigned short )0x7f7f;
+#ifdef IBMPC
+ *(--y) = 0xffff;
+#endif
+#ifdef DEC
+ *(--y) = 0xffff;
+#endif
+#ifdef MIEEE
+ ++y;
+ *y = 0xffff;
+#endif
+#endif /* !INFINITY */
+ 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
+}
+#endif /* LDBL_MANT_DIG == 24 */
+
+/* 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.
+ */
+static int ecmp(short unsigned int *a, short unsigned int *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 */
+}
+
+
+/*
+; Shift significand
+;
+; Shifts significand area up or down by the number of bits
+; given by the variable sc.
+*/
+static int eshift(short unsigned int *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.
+*/
+static int enormlz(short unsigned int *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
+
+
+
+/* ASCII string outputs for unix */
+
+
+#if 0
+void _IO_ldtostr(x, string, ndigs, flags, fmt)
+long double *x;
+char *string;
+int ndigs;
+int flags;
+char fmt;
+{
+unsigned short w[NI];
+char *t, *u;
+LDPARMS rnd;
+LDPARMS *ldp = &rnd;
+
+rnd.rlast = -1;
+rnd.rndprc = NBITS;
+
+if (sizeof(long double) == 16)
+ e113toe( (unsigned short *)x, w, ldp );
+else
+ e64toe( (unsigned short *)x, w, ldp );
+
+etoasc( w, string, ndigs, -1, ldp );
+if( ndigs == 0 && flags == 0 )
+ {
+ /* Delete the decimal point unless alternate format. */
+ t = string;
+ while( *t != '.' )
+ ++t;
+ u = t + 1;
+ while( *t != '\0' )
+ *t++ = *u++;
+ }
+if (*string == ' ')
+ {
+ t = string;
+ u = t + 1;
+ while( *t != '\0' )
+ *t++ = *u++;
+ }
+if (fmt == 'E')
+ {
+ t = string;
+ while( *t != 'e' )
+ ++t;
+ *t = 'E';
+ }
+}
+
+#endif
+
+/* This routine will not return more than NDEC+1 digits. */
+
+char *
+_ldtoa_r (struct _reent *ptr, long double d, int mode, int ndigits, int *decpt,
+ int *sign, char **rve)
+{
+unsigned short e[NI];
+char *s, *p;
+int k;
+LDPARMS rnd;
+LDPARMS *ldp = &rnd;
+char *outstr;
+
+rnd.rlast = -1;
+rnd.rndprc = NBITS;
+
+/* reentrancy addition to use mprec storage pool */
+if (ptr->_result)
+ {
+ ptr->_result->_k = ptr->_result_k;
+ ptr->_result->_maxwds = 1 << ptr->_result_k;
+ Bfree (ptr, ptr->_result);
+ ptr->_result = 0;
+ }
+
+#if LDBL_MANT_DIG == 24
+e24toe( (unsigned short *)&d, e, ldp );
+#elif LDBL_MANT_DIG == 53
+e53toe( (unsigned short *)&d, e, ldp );
+#elif LDBL_MANT_DIG == 64
+e64toe( (unsigned short *)&d, e, ldp );
+#else
+e113toe( (unsigned short *)&d, e, ldp );
+#endif
+
+if( eisneg(e) )
+ *sign = 1;
+else
+ *sign = 0;
+/* Mode 3 is "f" format. */
+if( mode != 3 )
+ ndigits -= 1;
+/* Mode 0 is for %.999 format, which is supposed to give a
+ minimum length string that will convert back to the same binary value.
+ For now, just ask for 20 digits which is enough but sometimes too many. */
+if( mode == 0 )
+ ndigits = 20;
+/* This sanity limit must agree with the corresponding one in etoasc, to
+ keep straight the returned value of outexpon. */
+if( ndigits > NDEC )
+ ndigits = NDEC;
+
+/* reentrancy addition to use mprec storage pool */
+ptr->_result = Balloc (ptr, 3);
+ptr->_result_k = 3;
+outstr = (char *)ptr->_result;
+
+etoasc( e, outstr, ndigits, mode, ldp );
+s = outstr;
+if( eisinf(e) || eisnan(e) )
+ {
+ *decpt = 9999;
+ goto stripspaces;
+ }
+*decpt = ldp->outexpon + 1;
+
+/* Transform the string returned by etoasc into what the caller wants. */
+
+/* Look for decimal point and delete it from the string. */
+s = outstr;
+while( *s != '\0' )
+ {
+ if( *s == '.' )
+ goto yesdecpt;
+ ++s;
+ }
+goto nodecpt;
+
+yesdecpt:
+
+/* Delete the decimal point. */
+while( *s != '\0' )
+ {
+ *s = *(s+1);
+ ++s;
+ }
+
+nodecpt:
+
+/* Back up over the exponent field. */
+while( *s != 'E' && s > outstr)
+ --s;
+*s = '\0';
+
+stripspaces:
+
+/* Strip leading spaces and sign. */
+p = outstr;
+while( *p == ' ' || *p == '-')
+ ++p;
+
+/* Find new end of string. */
+s = outstr;
+while( (*s++ = *p++) != '\0' )
+ ;
+--s;
+
+/* Strip trailing zeros. */
+if( mode == 2 )
+ k = 1;
+else if( ndigits > ldp->outexpon )
+ k = ndigits;
+else
+ k = ldp->outexpon;
+
+while( *(s-1) == '0' && ((s - outstr) > k))
+ *(--s) = '\0';
+
+/* In f format, flush small off-scale values to zero.
+ Rounding has been taken care of by etoasc. */
+if( mode == 3 && ((ndigits + ldp->outexpon) < 0))
+ {
+ s = outstr;
+ *s = '\0';
+ *decpt = 0;
+ }
+
+if( rve )
+ *rve = s;
+return outstr;
+}
+
+static void etoasc(short unsigned int *x, char *string, int ndigits, int outformat, LDPARMS *ldp)
+{
+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, ndigs;
+char *s, *ss;
+unsigned short m;
+unsigned short *equot = ldp->equot;
+
+ndigs = ndigits;
+rndsav = ldp->rndprc;
+#ifdef NANS
+if( eisnan(x) )
+ {
+ sprintf( string, " NaN " );
+ expon = 9999;
+ goto bxit;
+ }
+#endif
+ldp->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 " );
+ expon = 9999;
+ 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" );
+ expon = 9999;
+ 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, ldp );
+ efloor( t, w, ldp );
+ 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, ldp );
+ emul( p, t, t, ldp );
+ 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, ldp );
+ 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, ldp );
+ }
+ 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, ldp );
+ emul( r, t, t, ldp );
+ expon += k;
+ }
+ k /= 2;
+ if( k == 0 )
+ break;
+ p += NE;
+ r += NE;
+ }
+ ediv( t, eone, t, ldp );
+ }
+isone:
+/* Find the first (leading) digit. */
+emovi( t, w );
+emovz( w, t );
+emovi( y, w );
+emovz( w, y );
+eiremain( t, y, ldp );
+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, ldp );
+ digit = equot[NI-1];
+ expon -= 1;
+ }
+s = string;
+if( sign )
+ *s++ = '-';
+else
+ *s++ = ' ';
+/* Examine number of digits requested by caller. */
+if( outformat == 3 )
+ ndigs += expon;
+/*
+else 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;
+ if( ndigs < 0 )
+ {
+ ss = s;
+ goto doexp;
+ }
+ }
+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, ldp );
+ *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, ldp );
+ 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( ndigs < 0 )
+ {
+ /* This will print like "1E-6". */
+ *s = '1';
+ expon += 1;
+ goto doexp;
+ }
+ else 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:
+#ifdef __GO32__
+if( expon >= 0 )
+ sprintf( ss, "e+%02d", expon );
+else
+ sprintf( ss, "e-%02d", -expon );
+#else
+ sprintf( ss, "E%d", expon );
+#endif
+bxit:
+ldp->rndprc = rndsav;
+ldp->outexpon = expon;
+}
+
+
+
+
+/*
+; 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 );
+*/
+
+long double _strtold (char *s, char **se)
+{
+ long double x;
+ LDPARMS rnd;
+ LDPARMS *ldp = &rnd;
+ int lenldstr;
+
+ rnd.rlast = -1;
+ rnd.rndprc = NBITS;
+
+ lenldstr = asctoeg( s, (unsigned short *)&x, LDBL_MANT_DIG, ldp );
+ if (se)
+ *se = s + lenldstr;
+ return x;
+}
+
+#define REASONABLE_LEN 200
+
+static int
+asctoeg(char *ss, short unsigned int *y, int oprec, LDPARMS *ldp)
+{
+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, *lstr;
+int lenldstr;
+int mflag = 0;
+char tmpstr[REASONABLE_LEN];
+
+/* Copy the input string. */
+c = strlen (ss) + 2;
+if (c <= REASONABLE_LEN)
+ lstr = tmpstr;
+else
+ {
+ lstr = (char *) calloc (c, 1);
+ mflag = 1;
+ }
+s = ss;
+lenldstr = 0;
+while( *s == ' ' ) /* skip leading spaces */
+ {
+ ++s;
+ ++lenldstr;
+ }
+sp = lstr;
+for( k=0; k<c; k++ )
+ {
+ if( (*sp++ = *s++) == '\0' )
+ break;
+ }
+*sp = '\0';
+s = lstr;
+
+rndsav = ldp->rndprc;
+ldp->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, ldp );
+/* 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, ldp );
+ lexp += EXONE;
+ nexp -= 4096;
+ }
+ }
+p = &etens[NTEN][0];
+emov( eone, xt );
+exp = 1;
+do
+ {
+ if( exp & nexp )
+ emul( p, xt, xt, ldp );
+ p -= NE;
+ exp = exp + exp;
+ }
+while( exp <= MAXP );
+
+emovi( xt, tt );
+if( esign < 0 )
+ {
+ lexp -= tt[E];
+ k = edivm( tt, yy, ldp );
+ lexp += EXONE;
+ }
+else
+ {
+ lexp += tt[E];
+ k = emulm( tt, yy, ldp );
+ 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
+ldp->rndprc = oprec;
+emdnorm( yy, k, 0, lexp, 64, ldp );
+
+aexit:
+
+ldp->rndprc = rndsav;
+yy[0] = nsign;
+switch( oprec )
+ {
+#ifdef DEC
+ case 56:
+ todec( yy, y ); /* see etodec.c */
+ break;
+#endif
+#if LDBL_MANT_DIG == 53
+ case 53:
+ toe53( yy, y );
+ break;
+#elif LDBL_MANT_DIG == 24
+ case 24:
+ toe24( yy, y );
+ break;
+#elif LDBL_MANT_DIG == 64
+ case 64:
+ toe64( yy, y );
+ break;
+#elif LDBL_MANT_DIG == 113
+ case 113:
+ toe113( yy, y );
+ break;
+#else
+ case NBITS:
+ emovo( yy, y, ldp );
+ break;
+#endif
+ }
+lenldstr += s - lstr;
+if (mflag)
+ free (lstr);
+return lenldstr;
+}
+
+
+
+/* y = largest integer not greater than x
+ * (truncated toward minus infinity)
+ *
+ * unsigned short x[NE], y[NE]
+ * LDPARMS *ldp
+ *
+ * efloor( x, y, ldp );
+ */
+static unsigned short bmask[] = {
+0xffff,
+0xfffe,
+0xfffc,
+0xfff8,
+0xfff0,
+0xffe0,
+0xffc0,
+0xff80,
+0xff00,
+0xfe00,
+0xfc00,
+0xf800,
+0xf000,
+0xe000,
+0xc000,
+0x8000,
+0x0000,
+};
+
+static void efloor(short unsigned int *x, short unsigned int *y, LDPARMS *ldp)
+{
+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, ldp );
+ break;
+ }
+ }
+ }
+}
+
+
+
+static void eiremain(short unsigned int *den, short unsigned int *num, LDPARMS *ldp)
+{
+long ld, ln;
+unsigned short j;
+ unsigned short *equot = ldp->equot;
+
+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, ldp );
+}
+
+/* NaN bit patterns
+ */
+#ifdef MIEEE
+static unsigned short nan113[8] = {
+ 0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
+static unsigned short nan64[6] = {0x7fff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff};
+static unsigned short nan53[4] = {0x7fff, 0xffff, 0xffff, 0xffff};
+static unsigned short nan24[2] = {0x7fff, 0xffff};
+#else /* !MIEEE */
+static unsigned short nan113[8] = {0, 0, 0, 0, 0, 0, 0x8000, 0x7fff};
+static unsigned short nan64[6] = {0, 0, 0, 0, 0xc000, 0x7fff};
+static unsigned short nan53[4] = {0, 0, 0, 0x7ff8};
+static unsigned short nan24[2] = {0, 0x7fc0};
+#endif /* !MIEEE */
+
+
+static void enan (short unsigned int *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++;
+}
+
+
+
+
OSDN Git Service
