26#ifdef _CXSC_REAL_HPP_INCLUDED
34 a_real r_comp(a_real,a_intg);
35 a_real r_mant(a_real);
36 a_intg r_expo(a_real);
39inline double _double(
const real &a)
noexcept
49inline real _real(
const double &a)
noexcept
54inline real pred(
const real& r)
noexcept
57 ret = fi_lib::q_pred(r.w);
61inline real succ(
const real& r)
noexcept
64 ret = fi_lib::q_succ(r.w);
68inline a_intg expo(
const real &r)
noexcept
70 return r_expo(*(a_real*)&r.w);
73inline real comp(
const real &r, a_intg i)
noexcept
75 return real(r_comp(*(a_real*)&r.w,i));
78inline real mant(
const real &r)
noexcept
80 return real(r_mant(*(a_real*)&r.w));
83inline real operator -(
const real &a)
noexcept {
return -a.w; }
84inline real operator +(
const real &a)
noexcept {
return a; }
86inline real operator +(
const real &a,
const real &b)
noexcept {
return a.w+b.w; }
87inline real operator -(
const real &a,
const real &b)
noexcept {
return a.w-b.w; }
88inline real
operator *(
const real &a,
const real &b)
noexcept {
return a.w*b.w; }
89inline real
operator /(
const real &a,
const real &b)
noexcept {
return a.w/b.w; }
91inline real&
operator +=(real &a,
const real &b)
noexcept { a.w+=b.w;
return a; }
92inline real& operator -=(real &a,
const real &b)
noexcept { a.w-=b.w;
return a; }
93inline real&
operator *=(real &a,
const real &b)
noexcept { a.w*=b.w;
return a; }
94inline real&
operator /=(real &a,
const real &b)
noexcept { a.w/=b.w;
return a; }
96inline bool operator! (
const real& a)
noexcept {
return !a.w; }
97inline bool operator== (
const real& a,
const real& b)
noexcept {
return a.w==b.w; }
98inline bool operator!= (
const real& a,
const real& b)
noexcept {
return a.w!=b.w; }
99inline bool operator< (
const real& a,
const real& b)
noexcept {
return a.w<b.w; }
100inline bool operator<= (
const real& a,
const real& b)
noexcept {
return a.w<=b.w; }
101inline bool operator>= (
const real& a,
const real& b)
noexcept {
return a.w>=b.w; }
102inline bool operator> (
const real& a,
const real& b)
noexcept {
return a.w>b.w; }
104inline bool operator== (
const real& a,
const int & b)
noexcept {
return a.w==b; }
105inline bool operator!= (
const real& a,
const int & b)
noexcept {
return a.w!=b; }
106inline bool operator== (
const int & a,
const real& b)
noexcept {
return a==b.w; }
107inline bool operator!= (
const int & a,
const real& b)
noexcept {
return a!=b.w; }
108inline bool operator== (
const real& a,
const long & b)
noexcept {
return a.w==b; }
109inline bool operator!= (
const real& a,
const long & b)
noexcept {
return a.w!=b; }
110inline bool operator== (
const long & a,
const real& b)
noexcept {
return a==b.w; }
111inline bool operator!= (
const long & a,
const real& b)
noexcept {
return a!=b.w; }
112inline bool operator== (
const real& a,
const float & b)
noexcept {
return a.w==b; }
113inline bool operator!= (
const real& a,
const float & b)
noexcept {
return a.w!=b; }
114inline bool operator== (
const float & a,
const real& b)
noexcept {
return a==b.w; }
115inline bool operator!= (
const float & a,
const real& b)
noexcept {
return a!=b.w; }
116inline bool operator== (
const real& a,
const double & b)
noexcept {
return a.w==b; }
117inline bool operator!= (
const real& a,
const double & b)
noexcept {
return a.w!=b; }
118inline bool operator== (
const double & a,
const real& b)
noexcept {
return a==b.w; }
119inline bool operator!= (
const double & a,
const real& b)
noexcept {
return a!=b.w; }
122inline real
abs(
const real &a)
noexcept
130inline int sign(
const real &a)
noexcept
146 if (j >= -1021) { r = comp(mant(r),j); }
150 r = comp(mant(r), -1021);
152 else r = r * comp(0.5,j+1);
156inline real
pow2n(
const int n)
noexcept
158 return comp(0.5,n+1);
161inline real max(
const real & a,
const real & b) {
return a>b?a:b; }
162inline real min(
const real & a,
const real & b) {
return a<b?a:b; }
163inline real
Max(
const real & a,
const real & b) {
return a>b?a:b; }
171#include "rts_real.hpp"
177#if ROUND_C99_SAVE+ROUND_C99_QUICK
183#pragma fenv_access (on)
184 static inline void setround(
int r) {
185 unsigned int control_word;
186 _controlfp_s(&control_word,0,0);
189 _controlfp_s(&control_word,_RC_DOWN,_MCW_RC);
192 _controlfp_s(&control_word,_RC_NEAR,_MCW_RC);
195 _controlfp_s(&control_word,_RC_UP,_MCW_RC);
198 _controlfp_s(&control_word,_RC_CHOP,_MCW_RC);
201 _controlfp_s(&control_word,_RC_NEAR,_MCW_RC);
207#if ROUND_C96_SAVE+ROUND_C96_QUICK
209#define fegetround fegetround96
210#define fesetround fesetround96
216inline real addup(
const real &x,
const real &y)
220 ret = ra_addu(x.w,y.w);
222 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
225 fesetround(FE_UPWARD);
230 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
231 fesetround(FE_UPWARD);
235 unsigned int mask = 0xFFFFF;
236 _controlfp_s(&cw,0,0);
240 _controlfp_s(&cw,cw,mask);
244 ret = r_addu(_a_real(x.w), _a_real(y.w));
249inline real adddown(
const real &x,
const real &y)
253 ret = ra_addd(x.w,y.w);
255 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
258 fesetround(FE_DOWNWARD);
263 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
264 fesetround(FE_DOWNWARD);
268 unsigned int mask = 0xFFFFF;
269 _controlfp_s(&cw,0,0);
273 _controlfp_s(&cw,cw,mask);
277 ret = r_addd(_a_real(x.w), _a_real(y.w));
282inline real subup(
const real &x,
const real &y)
286 ret = ra_subu(x.w,y.w);
288 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
291 fesetround(FE_UPWARD);
296 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
297 fesetround(FE_UPWARD);
301 unsigned int mask = 0xFFFFF;
302 _controlfp_s(&cw,0,0);
306 _controlfp_s(&cw,cw,mask);
310 ret = r_subu(_a_real(x.w), _a_real(y.w));
315inline real subdown(
const real &x,
const real &y)
319 ret = ra_subd(x.w,y.w);
321 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
324 fesetround(FE_DOWNWARD);
329 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
330 fesetround(FE_DOWNWARD);
334 unsigned int mask = 0xFFFFF;
335 _controlfp_s(&cw,0,0);
339 _controlfp_s(&cw,cw,mask);
343 ret = r_subd(_a_real(x.w), _a_real(y.w));
348inline real multup(
const real &x,
const real &y)
352 ret = ra_mulu(x.w,y.w);
354 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
357 fesetround(FE_UPWARD);
362 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
363 fesetround(FE_UPWARD);
367 unsigned int mask = 0xFFFFF;
368 _controlfp_s(&cw,0,0);
372 _controlfp_s(&cw,cw,mask);
376 ret = r_mulu(_a_real(x.w), _a_real(y.w));
381inline real multdown(
const real &x,
const real &y)
385 ret = ra_muld(x.w,y.w);
387 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
390 fesetround(FE_DOWNWARD);
395 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
396 fesetround(FE_DOWNWARD);
400 unsigned int mask = 0xFFFFF;
401 _controlfp_s(&cw,0,0);
405 _controlfp_s(&cw,cw,mask);
409 ret = r_muld(_a_real(x.w), _a_real(y.w));
414inline real divup(
const real &x,
const real &y)
418 ret = ra_divu(x.w,y.w);
420 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
423 fesetround(FE_UPWARD);
428 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
429 fesetround(FE_UPWARD);
433 unsigned int mask = 0xFFFFF;
434 _controlfp_s(&cw,0,0);
438 _controlfp_s(&cw,cw,mask);
442 ret = r_divu(_a_real(x.w), _a_real(y.w));
447inline real divdown(
const real &x,
const real &y)
451 ret = ra_divd(x.w,y.w);
453 #elif ROUND_C99_SAVE+ROUND_C96_SAVE
456 fesetround(FE_DOWNWARD);
461 #elif ROUND_C99_QUICK+ROUND_C96_QUICK
462 fesetround(FE_DOWNWARD);
466 unsigned int mask = 0xFFFFF;
467 _controlfp_s(&cw,0,0);
471 _controlfp_s(&cw,cw,mask);
475 ret = r_divd(_a_real(x.w), _a_real(y.w));
488 if ((((a_btyp*)&a)[HIGHREAL] & 0x7FF00000L) != 0x7FF00000L)
490 if ((((a_btyp*)&a)[HIGHREAL] & 0x000FFFFFL) != 0L)
492 if (((a_btyp*)&a)[LOWREAL] != 0L)
506 if ((((a_btyp*)&a)[HIGHREAL] & 0x7FF00000L) != 0x7FF00000L)
509 if ((((a_btyp*)&a)[HIGHREAL] & 0x000FFFFFL) == 0L)
511 if (((a_btyp*)&a)[LOWREAL] == 0L)
528 if ((((a_btyp*)&a)[HIGHREAL] & 0xFFF00000L) != 0xFFF00000L)
530 if ((((a_btyp*)&a)[HIGHREAL] & 0x000FFFFFL) != 0x00080000L)
532 if (((a_btyp*)&a)[LOWREAL] != 0L)
The namespace cxsc, providing all functionality of the class library C-XSC.
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
bool IsQuietNaN(const real &a)
Returns if the given real value represents the value of a quiet NaN.
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
bool IsSignalingNaN(const real &a)
Returns if the given real value represents the value of a signaling NaN.
real pow2n(const int n) noexcept
Returns the value of .
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
void times2pown(cinterval &x, int n) noexcept
Fast multiplication of reference parameter [z] with .
real Max(const real &a, const real &b)
Returns the greater value of two real values (for Compatibility with former r_util....
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
bool IsInfinity(const real &a)
Returns if the given real value represents the value infinity.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.