35void d_outp(
char *buffer, Dotprecision c,
36 int FormatFlag,
int FracDigits,
int rnd,
40extern __declspec(thread)
char *dm;
41#elif __APPLE__ && !CXSC_FORCE_TLS
44extern __thread
char *dm;
48char* GetHexDigits (
char* s, a_btyp& x,
int count);
50int r_outpx (
char *buffer, a_real s,a_intg FormatFlag, a_intg FracDigits, a_intg rnd, a_intg *length);
53#define ISINFINITYPLUS -1
54#define ISINFINITYMINUS -2
56#define ISSIGNALINGNAN -4
60 a_btyp* b = (a_btyp*) &a;
64 for (i=0; i < realwidth-19; i++) cs[i] =
' ';
66 sprintf (&cs[strlen(cs)],
"%s", ((b[HIGHREAL] & 0x80000000L) ?
"-" :
"+"));
67 sprintf (&cs[strlen(cs)],
"%c",
'1');
68 sprintf (&cs[strlen(cs)],
"%05lX", (b[HIGHREAL] & 0xFFFFFL));
69 sprintf (&cs[strlen(cs)],
"%08lX",(
long unsigned int)(b[LOWREAL]));
70 sprintf (&cs[strlen(cs)],
"e%03X",(
unsigned int)((b[HIGHREAL] >> 20) & 0x7FF));
74std::string & operator<<(std::string &s,
const real& a)
noexcept
77 static __declspec(thread)
char cs[256];
78#elif __APPLE__ && !CXSC_FORCE_TLS
81 static __thread
char cs[256];
84 if (ioflags.isset(IOFlags::hex))
86 a_btyp* b = (a_btyp*) &a;
90 for (i=0; i < realwidth-19; i++) cs[i] =
' ';
92 sprintf (&cs[strlen(cs)],
"%s", ((b[HIGHREAL] & 0x80000000L) ?
"-" :
"+"));
93 sprintf (&cs[strlen(cs)],
"%c",
'1');
94 sprintf (&cs[strlen(cs)],
"%05lX", (b[HIGHREAL] & 0xFFFFFL));
95 sprintf (&cs[strlen(cs)],
"%08lX",(
long unsigned int)(b[LOWREAL]));
96 sprintf (&cs[strlen(cs)],
"e%03X",(
unsigned int)((b[HIGHREAL] >> 20) & 0x7FF));
98 }
else if (ioflags.isset(IOFlags::rndnone))
105 if (realdigits && realwidth)
106 sprintf (cs,
"%*.*g", realwidth, realdigits, a.w);
108 sprintf (cs,
"%*g", realwidth, a.w);
110 sprintf (cs,
"%g", a.w);
116 a_intg length, formatflag, addblanks;
117 a_intg digits = realdigits;
120 if (d_init_dm () == -1)
127 if (ioflags.isset(IOFlags::rndup))
129 else if (ioflags.isset(IOFlags::rnddown))
134 if (ioflags.isset(IOFlags::variable))
135 formatflag = realwidth;
136 else if (ioflags.isset(IOFlags::varfixwidth))
137 formatflag = realwidth, digits = -digits;
139 formatflag = (ioflags.isset(IOFlags::fixed)) ? 0 : -1;
141 switch (r_outpx (dm, a.w, formatflag, digits, rnd, &length))
148 if (ioflags.isset(IOFlags::blank))
150 else if (ioflags.isset(IOFlags::noblank))
155 str = (
char*)
"<+Infinity>";
157 case ISINFINITYMINUS:
158 str = (
char*)
"<-Infinity>";
161 str = (
char*)
"<QuietNaN>";
164 str = (
char*)
"<SignalingNaN>";
167 str = (
char*)
"<ERROR>";
170 length = strlen(str);
171 addblanks = (length < realwidth) ? realwidth - length : 0;
173 if (ioflags.isset(IOFlags::rightjust))
174 for (;addblanks; addblanks--)
179 for (;addblanks; addblanks--)
185std::ostream & operator <<(std::ostream &o,
const real &a)
noexcept
193std::string & operator>> (std::string & str,
real& a)
noexcept
195 char *s=
new char[str.size()+1];
197 strcpy(s,str.c_str());
199 if (ioflags.isset(IOFlags::hex))
201 a_btyp* b = (a_btyp*) &a;
205 s = cskipwhitespaces (s);
208 b[HIGHREAL] |= 0x80000000L;
210 }
else if (*s ==
'+')
222 s = GetHexDigits (s, x, 5);
224 s = GetHexDigits (s, x, 8);
228 s = GetHexDigits (s, x, 3);
229 b[HIGHREAL] |= x << 20;
236 if (ioflags.isset(IOFlags::rndup))
238 else if (ioflags.isset(IOFlags::rnddown))
246 strcpy(s,str.c_str());
247 a = rnd (dot, rndfl);
253void operator >>(
const char *a,
real &b)
noexcept
258void operator >>(
const string &a,
real &b)
noexcept
263std::istream& operator>> (std::istream& s,
real& a)
noexcept
265 if (ioflags.isset(IOFlags::hex))
283 c = skipwhitespaces (s);
284 for (i=0; i < 19; i++)
287 if (s.good()) s.get(c);
else c =
'\0';
296 if (ioflags.isset(IOFlags::rndup))
298 else if (ioflags.isset(IOFlags::rnddown))
305 a = rnd (dot, rndfl);
318char* GetHexDigits (
char* s, a_btyp& x,
int count)
322 for (x=0,i=0; i < count && *s; s++,i++) {
323 if ((c = *s) >=
'A') c -=
'A' - 10;
else c -=
'0';
324 if (c < 0 || c > 0xF) c = 0;
376#define ISINFINITYPLUS -1
377#define ISINFINITYMINUS -2
379#define ISSIGNALINGNAN -4
381#define MANT_INFINITY(a) ((a)[0]==HIDDEN_BIT && (a)[1]==ZERO)
382#define SIGNALING(a) ((a) & SIGNAL_BIT)
383#define SIGNAL_BIT ((a_btyp)0x00080000L)
385int r_outpx(
char *buffer, a_real s, a_intg FormatFlag,
386 a_intg FracDigits, a_intg rnd, a_intg *length)
388 a_intg ActWidth,DecPlaces,expo,IntDigits,MinNumChars;
389 a_intg dexpo,digits,bdp,k,l,addpoint;
390 a_intg HoldWidth = (FracDigits < 0);
395 FracDigits = -FracDigits;
398 zero = b_deko(s,&expo,mant,&vz);
405 if (MANT_INFINITY(mant))
407 k = (vz) ? ISINFINITYMINUS : ISINFINITYPLUS;
410 k = (SIGNALING(mant[0])) ? ISSIGNALINGNAN : ISQUIETNAN;
415 for (k=D_U_RATIO;k<BSIZE;k++)
421 if (FormatFlag > 0 && FormatFlag-FracDigits <= 2)
423 FormatFlag = FracDigits+3;
425 if (!zero && FormatFlag > 0)
427 dexpo = (a_intg) ((expo*30103L)/100000L);
428 if (dexpo < -((FracDigits+1)/2) ||
429 (dexpo > 0 && dexpo >= FormatFlag-FracDigits-2))
434 FracDigits = (FracDigits < 5) ? 0 : FracDigits-5;
440 bdp = (BUFFERSIZE-8)-(FormatFlag == -1 ? 0 : FracDigits);
446 addpoint = (FracDigits == 0) ? 0 : 1;
450 if (FormatFlag == -1)
452 DecPlaces = FracDigits;
453 ActWidth = DecPlaces+ExpDigits+4+addpoint;
459 *buffer++ = (vz) ?
'-' :
'+';
463 *buffer++ = XSC_DECIMAL_POINT;
464 for (k=0;k<DecPlaces;k++) *buffer++ =
'0';
466 *buffer++ = EXPONENT_E;
467 *buffer++ = PLUS_SIGN;
468 for (k=0;k<ExpDigits;k++)
478 digits = DecPlaces+(1+2);
480 b_out(mant,expo,digits,buffer,&bdp,&dexpo);
482 if (dexpo>0 && dexpo>DecPlaces+2)
485 b_rnd(rnd,buffer,digits,DecPlaces+1,&bdp,&dexpo);
489 buffer[bdp-dexpo-1] = buffer[bdp-dexpo];
490 buffer[bdp-dexpo] = XSC_DECIMAL_POINT;
492 buffer[bdp-dexpo+DecPlaces+1] = EXPONENT_E;
493 buffer[bdp-dexpo+DecPlaces+2] = (dexpo<0) ? MINUS_SIGN : PLUS_SIGN;
494 expo = (dexpo<0) ? -dexpo : dexpo;
495 for (k=ExpDigits;k>0;k--)
497 buffer[bdp-dexpo+DecPlaces+2+k] = expo%10+
'0';
500 *length = 2+addpoint+DecPlaces+2+ExpDigits;
502 l = bdp - 1 - addpoint - dexpo;
503 buffer[l] = (vz) ?
'-' :
'+';
504 for (k=0;k<*length;k++,l++)
505 buffer[k] = buffer[l];
516 *length = FracDigits+2+addpoint;
517 *buffer++ = (vz) ?
'-' :
'+';
521 *buffer++ = XSC_DECIMAL_POINT;
522 for (k=0;k<FracDigits;k++)
531 IntDigits = ((expo+1)*61)/200+1;
539 for (k=0;k<=FracDigits+2;k++)
542 digits = IntDigits+FracDigits+2;
543 b_out(mant,expo,digits,buffer,&bdp,&dexpo);
555 b_rnd(rnd,buffer,digits,IntDigits+FracDigits,&bdp,&dexpo);
563 for (k=(bdp+1)-IntDigits;k<(bdp+1)+FracDigits;k++)
568 if (k==(bdp+1)+FracDigits)
572 MinNumChars = IntDigits+FracDigits+1+addpoint;
577 for (k=bdp-IntDigits;k<bdp;k++)
578 buffer[k] = buffer[k+1];
579 buffer[bdp] = XSC_DECIMAL_POINT;
582 *length = MinNumChars;
586 l = bdp - 1 - addpoint - dexpo;
587 buffer[l] = (vz) ?
'-' :
'+';
588 for (k=0;k<*length;k++,l++)
589 buffer[k] = buffer[l];
The Data Type dotprecision.
The namespace cxsc, providing all functionality of the class library C-XSC.
bool IsQuietNaN(const real &a)
Returns if the given real value represents the value of a quiet NaN.
bool IsSignalingNaN(const real &a)
Returns if the given real value represents the value of a signaling NaN.
string realToHex(const real &a)
Returns a real number in hexadecimal format as string.
bool IsInfinity(const real &a)
Returns if the given real value represents the value infinity.