home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c083 / 14.ddi / GENINC.PAK / BCD.H < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-02  |  17.9 KB  |  714 lines
  1. /*  bcd.h
  2.  
  3.     BCD Number Library - Include File
  4.     class bcd:  declarations for decimal numbers.
  5.  
  6. */
  7.  
  8. /*
  9.  *      C/C++ Run Time Library - Version 6.0
  10.  *
  11.  *      Copyright (c) 1987, 1993 by Borland International
  12.  *      All Rights Reserved.
  13.  *
  14.  */
  15.  
  16. #ifndef __cplusplus
  17. #error Must use C++ for the type bcd.
  18. #endif
  19.  
  20. #if !defined(__BCD_H)
  21. #define __BCD_H
  22.  
  23. #if !defined(___DEFS_H)
  24. #include <_defs.h>
  25. #endif
  26.  
  27. #if !defined(__MATH_H)
  28. #include <math.h>
  29. #endif
  30.  
  31. #if !defined(__FLAT__)
  32.  
  33. #if !defined(__IOSTREAM_H)
  34. #include <iostream.h>
  35. #endif
  36.  
  37. #pragma option -Vo-
  38. #if defined(__BCOPT__) && !defined(_RTL_ALLOW_po) && !defined(__FLAT__)
  39. #pragma option -po-
  40. #endif
  41.  
  42. #define _BcdMaxDecimals     5000
  43.  
  44. _CLASSDEF(bcd)
  45.  
  46. class _CLASSTYPE bcd {
  47.  
  48. public:
  49.     // constructors
  50.     _Cdecl bcd();
  51.     _Cdecl bcd(int x);
  52.     _Cdecl bcd(unsigned int x);
  53.     _Cdecl bcd(long x);
  54.     _Cdecl bcd(unsigned long x);
  55.     _Cdecl bcd(double x, int decimals = _BcdMaxDecimals);
  56.     _Cdecl bcd(long double x, int decimals = _BcdMaxDecimals);
  57.  
  58.     // bcd manipulations
  59.     friend long double _Cdecl real(bcd _FAR &);   // Return the real part
  60.  
  61.     // Overloaded ANSI C math functions
  62.     friend bcd _Cdecl _FARFUNC abs(bcd _FAR &);
  63.     friend bcd _Cdecl _FARFUNC acos(bcd _FAR &);
  64.     friend bcd _Cdecl _FARFUNC asin(bcd _FAR &);
  65.     friend bcd _Cdecl _FARFUNC atan(bcd _FAR &);
  66.     friend bcd _Cdecl _FARFUNC cos(bcd _FAR &);
  67.     friend bcd _Cdecl _FARFUNC cosh(bcd _FAR &);
  68.     friend bcd _Cdecl _FARFUNC exp(bcd _FAR &);
  69.     friend bcd _Cdecl _FARFUNC log(bcd _FAR &);
  70.     friend bcd _Cdecl _FARFUNC log10(bcd _FAR &);
  71.     friend bcd _Cdecl _FARFUNC pow(bcd _FAR & base, bcd _FAR & expon);
  72.     friend bcd _Cdecl _FARFUNC sin(bcd _FAR &);
  73.     friend bcd _Cdecl _FARFUNC sinh(bcd _FAR &);
  74.     friend bcd _Cdecl _FARFUNC sqrt(bcd _FAR &);
  75.     friend bcd _Cdecl _FARFUNC tan(bcd _FAR &);
  76.     friend bcd _Cdecl _FARFUNC tanh(bcd _FAR &);
  77.  
  78.     // Binary Operator Functions
  79.     friend bcd _Cdecl _FARFUNC operator+(bcd _FAR &, bcd _FAR &);
  80.     friend bcd _Cdecl _FARFUNC operator+(long double, bcd _FAR &);
  81.     friend bcd _Cdecl _FARFUNC operator+(bcd _FAR &, long double);
  82.     friend bcd _Cdecl _FARFUNC operator-(bcd _FAR &, bcd _FAR &);
  83.     friend bcd _Cdecl _FARFUNC operator-(long double, bcd _FAR &);
  84.     friend bcd _Cdecl _FARFUNC operator-(bcd _FAR &, long double);
  85.     friend bcd _Cdecl _FARFUNC operator*(bcd _FAR &, bcd _FAR &);
  86.     friend bcd _Cdecl _FARFUNC operator*(bcd _FAR &, long double);
  87.     friend bcd _Cdecl _FARFUNC operator*(long double, bcd _FAR &);
  88.     friend bcd _Cdecl _FARFUNC operator/(bcd _FAR &, bcd _FAR &);
  89.     friend bcd _Cdecl _FARFUNC operator/(bcd _FAR &, long double);
  90.     friend bcd _Cdecl _FARFUNC operator/(long double, bcd _FAR &);
  91.     friend int _Cdecl _FARFUNC operator==(bcd _FAR &, bcd _FAR &);
  92.     friend int _Cdecl _FARFUNC operator!=(bcd _FAR &, bcd _FAR &);
  93.     friend int _Cdecl _FARFUNC operator>=(bcd _FAR &, bcd _FAR &);
  94.     friend int _Cdecl _FARFUNC operator<=(bcd _FAR &, bcd _FAR &);
  95.     friend int _Cdecl _FARFUNC operator>(bcd _FAR &, bcd _FAR &);
  96.     friend int _Cdecl _FARFUNC operator<(bcd _FAR &, bcd _FAR &);
  97.     bcd _FAR & _Cdecl operator+=(bcd _FAR &);
  98.     bcd _FAR & _Cdecl operator+=(long double);
  99.     bcd _FAR & _Cdecl operator-=(bcd _FAR &);
  100.     bcd _FAR & _Cdecl operator-=(long double);
  101.     bcd _FAR & _Cdecl operator*=(bcd _FAR &);
  102.     bcd _FAR & _Cdecl operator*=(long double);
  103.     bcd _FAR & _Cdecl operator/=(bcd _FAR &);
  104.     bcd _FAR & _Cdecl operator/=(long double);
  105.     bcd  _Cdecl operator+();
  106.     bcd  _Cdecl operator-();
  107.  
  108. // Implementation
  109. private:
  110.     long mantissa[2];
  111.     int expo;
  112. };
  113.  
  114. // const bcd _bcd_zero(0);
  115.  
  116. enum _bcdexpo {
  117.     _ExpoZero,
  118.     _ExpoInf,
  119.     _ExpoNan,
  120. };
  121.  
  122. extern "C" {
  123. long double pascal _FARFUNC __bcd_tobinary(const bcd far *p);
  124. void pascal _FARFUNC __bcd_todecimal(long double x, int decimals, bcd far *p);
  125. long double pascal _FARFUNC __bcd_log10(bcd far *p);
  126. void pascal _FARFUNC __bcd_pow10(int n, bcd far *p);
  127. }
  128.  
  129. inline _Cdecl bcd::bcd()
  130. {
  131. /* if you want zero ...
  132.     mantissa[0] = 0;
  133.     mantissa[1] = 0;
  134.     expo = ExpoZero;
  135. */
  136. }
  137.  
  138. inline _Cdecl bcd::bcd(long double x, int decimals)
  139. {
  140.     __bcd_todecimal(x,decimals,this);
  141. }
  142.  
  143. inline _Cdecl bcd::bcd(double x, int decimals)
  144. {
  145.     __bcd_todecimal(x,decimals,this);
  146. }
  147.  
  148. inline _Cdecl bcd::bcd(int x)
  149. {
  150.     mantissa[0] = x;
  151.     mantissa[1] = x >= 0 ? 0 : -1;
  152.     expo = 0;
  153. }
  154.  
  155. inline _Cdecl bcd::bcd(unsigned int x)
  156. {
  157.     mantissa[0] = x;
  158.     mantissa[1] = 0;
  159.     expo = 0;
  160. }
  161.  
  162. inline _Cdecl bcd::bcd(long x)
  163. {
  164.     mantissa[0] = x;
  165.     mantissa[1] = x >= 0 ? 0 : -1;
  166.     expo = 0;
  167. }
  168.  
  169. inline _Cdecl bcd::bcd(unsigned long x)
  170. {
  171.     mantissa[0] = x;
  172.     mantissa[1] = 0;
  173.     expo = 0;
  174. }
  175.  
  176. inline long double _Cdecl real(bcd& z)
  177. {
  178.     return __bcd_tobinary(&z);
  179. }
  180.  
  181. // Definitions of compound-assignment operator member functions
  182.  
  183. inline bcd& _Cdecl bcd::operator+=(bcd& b)
  184. {
  185.     __bcd_todecimal(real(*this)+real(b),_BcdMaxDecimals,this);
  186.     return *this;
  187. }
  188.  
  189. inline bcd& _Cdecl bcd::operator+=(long double b)
  190. {
  191.     __bcd_todecimal(real(*this)+b,_BcdMaxDecimals,this);
  192.     return *this;
  193. }
  194.  
  195. inline bcd& _Cdecl bcd::operator-=(bcd& b)
  196. {
  197.     __bcd_todecimal(real(*this)-real(b),_BcdMaxDecimals,this);
  198.     return *this;
  199. }
  200.  
  201. inline bcd& _Cdecl bcd::operator-=(long double b)
  202. {
  203.     __bcd_todecimal(real(*this)-b,_BcdMaxDecimals,this);
  204.     return *this;
  205. }
  206.  
  207. inline bcd& _Cdecl bcd::operator*=(bcd& b)
  208. {
  209.     __bcd_todecimal(real(*this)*real(b),_BcdMaxDecimals,this);
  210.     return *this;
  211. }
  212.  
  213. inline bcd& _Cdecl bcd::operator*=(long double b)
  214. {
  215.     __bcd_todecimal(real(*this)*b,_BcdMaxDecimals,this);
  216.     return *this;
  217. }
  218.  
  219. inline bcd& _Cdecl bcd::operator/=(bcd& b)
  220. {
  221.     __bcd_todecimal(real(*this)/real(b),_BcdMaxDecimals,this);
  222.     return *this;
  223. }
  224.  
  225. inline bcd& _Cdecl bcd::operator/=(long double b)
  226. {
  227.     __bcd_todecimal(real(*this)/b,_BcdMaxDecimals,this);
  228.     return *this;
  229. }
  230.  
  231.  
  232. // Definitions of non-member binary operator functions
  233.  
  234. inline bcd _Cdecl operator+(bcd& a, bcd& b)
  235. {
  236.     return bcd(real(a) + real(b));
  237. }
  238.  
  239. inline bcd _Cdecl operator+(long double a, bcd& b)
  240. {
  241.     return bcd(a + real(b));
  242. }
  243.  
  244. inline bcd _Cdecl operator+(bcd& a, long double b)
  245. {
  246.     return bcd(real(a) + b);
  247. }
  248.  
  249. inline bcd _Cdecl operator-(bcd& a, bcd& b)
  250. {
  251.     return bcd(real(a) - real(b));
  252. }
  253.  
  254. inline bcd _Cdecl operator-(long double a, bcd& b)
  255. {
  256.     return bcd(a - real(b));
  257. }
  258.  
  259. inline bcd _Cdecl operator-(bcd& a, long double b)
  260. {
  261.     return bcd(real(a) - b);
  262. }
  263.  
  264. inline bcd _Cdecl operator*(bcd& a, bcd& b)
  265. {
  266.     return bcd(real(a) * real(b));
  267. }
  268.  
  269. inline bcd _Cdecl operator*(bcd& a, long double b)
  270. {
  271.     return bcd(real(a) * b);
  272. }
  273.  
  274. inline bcd _Cdecl operator*(long double a, bcd& b)
  275. {
  276.     return bcd(a * real(b));
  277. }
  278.  
  279. inline bcd _Cdecl operator/(bcd& a, bcd& b)
  280. {
  281.     return bcd(real(a) / real(b));
  282. }
  283.  
  284. inline bcd _Cdecl operator/(long double a, bcd& b)
  285. {
  286.     return bcd(a / real(b));
  287. }
  288.  
  289. inline bcd _Cdecl operator/(bcd& a, long double b)
  290. {
  291.     return bcd(real(a) / b);
  292. }
  293.  
  294. inline int _Cdecl operator==(bcd& a, bcd& b)
  295. {
  296.     return real(a) == real(b);
  297. }
  298.  
  299. inline int _Cdecl operator!=(bcd& a, bcd& b)
  300. {
  301.     return real(a) != real(b);
  302. }
  303.  
  304. inline int _Cdecl operator>=(bcd& a, bcd& b)
  305. {
  306.     return real(a) >= real(b);
  307. }
  308.  
  309. inline int _Cdecl operator<=(bcd& a, bcd& b)
  310. {
  311.     return real(a) <= real(b);
  312. }
  313.  
  314. inline int _Cdecl operator>(bcd& a, bcd& b)
  315. {
  316.     return real(a) > real(b);
  317. }
  318.  
  319. inline int _Cdecl operator<(bcd& a, bcd& b)
  320. {
  321.     return real(a) < real(b);
  322. }
  323.  
  324. inline bcd _Cdecl bcd::operator+()
  325. {
  326.     return *this;
  327. }
  328.  
  329. inline bcd _Cdecl bcd::operator-()
  330. {
  331. //  return bcd(-real(this));
  332.  
  333. // 1's comp
  334.     mantissa[0] = - ++ mantissa[0];
  335.     mantissa[1] = - ++ mantissa[1];
  336. // inc
  337.     if (++mantissa[0] == 0) ++mantissa[1];
  338.     return *this;
  339. }
  340.  
  341. inline bcd _Cdecl abs(bcd& a)   { return bcd(fabs(real(a)));}
  342. inline bcd _Cdecl acos(bcd& a)  { return bcd(acos(real(a)));}
  343. inline bcd _Cdecl asin(bcd& a)  { return bcd(asin(real(a)));}
  344. inline bcd _Cdecl atan(bcd& a)  { return bcd(atan(real(a)));}
  345. inline bcd _Cdecl cos(bcd& a)   { return bcd(cos(real(a)));}
  346. inline bcd _Cdecl cosh(bcd& a)  { return bcd(cosh(real(a)));}
  347. inline bcd _Cdecl exp(bcd& a)   { return bcd(exp(real(a)));}
  348. inline bcd _Cdecl log(bcd& a)   { return bcd(log(real(a)));}
  349. inline bcd _Cdecl log10(bcd& a) { return bcd(__bcd_log10(&a));}
  350. inline bcd _Cdecl sin(bcd& a)   { return bcd(sin(real(a)));}
  351. inline bcd _Cdecl sinh(bcd& a)  { return bcd(sinh(real(a)));}
  352. inline bcd _Cdecl sqrt(bcd& a)  { return bcd(sqrt(real(a)));}
  353. inline bcd _Cdecl tan(bcd& a)   { return bcd(tan(real(a)));}
  354. inline bcd _Cdecl tanh(bcd& a)  { return bcd(tanh(real(a)));}
  355.  
  356. inline bcd _Cdecl pow(bcd& a, bcd& b)   { return bcd(pow(real(a),real(b)));}
  357. inline void _Cdecl pow10(int n, bcd& a) { __bcd_pow10(n,&a);}
  358.  
  359. // bcd stream I/O
  360.  
  361. ostream _FAR & pascal _FARFUNC operator<<(ostream _FAR &, bcd _FAR &);
  362. istream _FAR & pascal _FARFUNC operator>>(istream _FAR &, bcd _FAR &);
  363.  
  364. #pragma option -Vo.
  365. #if defined(__BCOPT__) && !defined(_RTL_ALLOW_po) && !defined(__FLAT__)
  366. #pragma option -po.
  367. #endif
  368.  
  369. #else   /* defined __FLAT__  */
  370.  
  371. #if !defined(RC_INVOKED)
  372. #pragma option -a-     /* Assume byte packing  */
  373. #endif
  374.  
  375. #define _BcdMaxDecimals     5000
  376.  
  377. _CLASSDEF(bcd)
  378.  
  379. class _EXPCLASS bcd {
  380.  
  381. public:
  382.     // constructors
  383.     _RTLENTRY bcd();
  384.     _RTLENTRY bcd(int x);
  385.     _RTLENTRY bcd(unsigned int x);
  386.     _RTLENTRY bcd(long x);
  387.     _RTLENTRY bcd(unsigned long x);
  388.     _RTLENTRY bcd(double x, int decimals = _BcdMaxDecimals);
  389.     _RTLENTRY bcd(long double x, int decimals = _BcdMaxDecimals);
  390.  
  391.     // bcd manipulations
  392.     friend long double _RTLENTRY real(bcd &);   // Return the real part
  393.  
  394.     // Overloaded ANSI C math functions
  395.     friend bcd _RTLENTRY _EXPFUNC abs(bcd &);
  396.     friend bcd _RTLENTRY _EXPFUNC acos(bcd &);
  397.     friend bcd _RTLENTRY _EXPFUNC asin(bcd &);
  398.     friend bcd _RTLENTRY _EXPFUNC atan(bcd &);
  399.     friend bcd _RTLENTRY _EXPFUNC cos(bcd &);
  400.     friend bcd _RTLENTRY _EXPFUNC cosh(bcd &);
  401.     friend bcd _RTLENTRY _EXPFUNC exp(bcd &);
  402.     friend bcd _RTLENTRY _EXPFUNC log(bcd &);
  403.     friend bcd _RTLENTRY _EXPFUNC log10(bcd &);
  404.     friend bcd _RTLENTRY _EXPFUNC pow(bcd & base, bcd & expon);
  405.     friend bcd _RTLENTRY _EXPFUNC sin(bcd &);
  406.     friend bcd _RTLENTRY _EXPFUNC sinh(bcd &);
  407.     friend bcd _RTLENTRY _EXPFUNC sqrt(bcd &);
  408.     friend bcd _RTLENTRY _EXPFUNC tan(bcd &);
  409.     friend bcd _RTLENTRY _EXPFUNC tanh(bcd &);
  410.  
  411.     // Binary Operator Functions
  412.     friend bcd _RTLENTRY _EXPFUNC operator+(bcd &, bcd &);
  413.     friend bcd _RTLENTRY _EXPFUNC operator+(long double, bcd &);
  414.     friend bcd _RTLENTRY _EXPFUNC operator+(bcd &, long double);
  415.     friend bcd _RTLENTRY _EXPFUNC operator-(bcd &, bcd &);
  416.     friend bcd _RTLENTRY _EXPFUNC operator-(long double, bcd &);
  417.     friend bcd _RTLENTRY _EXPFUNC operator-(bcd &, long double);
  418.     friend bcd _RTLENTRY _EXPFUNC operator*(bcd &, bcd &);
  419.     friend bcd _RTLENTRY _EXPFUNC operator*(bcd &, long double);
  420.     friend bcd _RTLENTRY _EXPFUNC operator*(long double, bcd &);
  421.     friend bcd _RTLENTRY _EXPFUNC operator/(bcd &, bcd &);
  422.     friend bcd _RTLENTRY _EXPFUNC operator/(bcd &, long double);
  423.     friend bcd _RTLENTRY _EXPFUNC operator/(long double, bcd &);
  424.     friend int _RTLENTRY _EXPFUNC operator==(bcd &, bcd &);
  425.     friend int _RTLENTRY _EXPFUNC operator!=(bcd &, bcd &);
  426.     friend int _RTLENTRY _EXPFUNC operator>=(bcd &, bcd &);
  427.     friend int _RTLENTRY _EXPFUNC operator<=(bcd &, bcd &);
  428.     friend int _RTLENTRY _EXPFUNC operator>(bcd &, bcd &);
  429.     friend int _RTLENTRY _EXPFUNC operator<(bcd &, bcd &);
  430.     bcd & _RTLENTRY operator+=(bcd &);
  431.     bcd & _RTLENTRY operator+=(long double);
  432.     bcd & _RTLENTRY operator-=(bcd &);
  433.     bcd & _RTLENTRY operator-=(long double);
  434.     bcd & _RTLENTRY operator*=(bcd &);
  435.     bcd & _RTLENTRY operator*=(long double);
  436.     bcd & _RTLENTRY operator/=(bcd &);
  437.     bcd & _RTLENTRY operator/=(long double);
  438.     bcd  _RTLENTRY operator+();
  439.     bcd  _RTLENTRY operator-();
  440.  
  441. // Implementation
  442. private:
  443.     long mantissa[2];
  444.     int expo;
  445. };
  446.  
  447. // const bcd bcd_zero(0);
  448.  
  449. enum _bcdexpo {
  450.     _ExpoZero,
  451.     _ExpoInf,
  452.     _ExpoNan,
  453. };
  454.  
  455. extern "C" {
  456. long double _RTLENTRY _EXPFUNC __bcd_tobinary (const bcd *p);
  457. void        _RTLENTRY _EXPFUNC __bcd_todecimal(long double x, int decimals, bcd *p);
  458. long double _RTLENTRY _EXPFUNC __bcd_log10    (bcd *p);
  459. void        _RTLENTRY _EXPFUNC __bcd_pow10    (int n, bcd *p);
  460. }
  461.  
  462. inline _RTLENTRY bcd::bcd()
  463. {
  464. /* if you want zero ...
  465.     mantissa[0] = 0;
  466.     mantissa[1] = 0;
  467.     expo = ExpoZero;
  468. */
  469. }
  470.  
  471. inline _RTLENTRY bcd::bcd(long double x, int decimals)
  472. {
  473.     __bcd_todecimal(x,decimals,this);
  474. }
  475.  
  476. inline _RTLENTRY bcd::bcd(double x, int decimals)
  477. {
  478.     __bcd_todecimal(x,decimals,this);
  479. }
  480.  
  481. inline _RTLENTRY bcd::bcd(int x)
  482. {
  483.     mantissa[0] = x;
  484.     mantissa[1] = x >= 0 ? 0 : -1;
  485.     expo = 0;
  486. }
  487.  
  488. inline _RTLENTRY bcd::bcd(unsigned int x)
  489. {
  490.     mantissa[0] = x;
  491.     mantissa[1] = 0;
  492.     expo = 0;
  493. }
  494.  
  495. inline _RTLENTRY bcd::bcd(long x)
  496. {
  497.     mantissa[0] = x;
  498.     mantissa[1] = x >= 0 ? 0 : -1;
  499.     expo = 0;
  500. }
  501.  
  502. inline _RTLENTRY bcd::bcd(unsigned long x)
  503. {
  504.     mantissa[0] = x;
  505.     mantissa[1] = 0;
  506.     expo = 0;
  507. }
  508.  
  509. inline long double _RTLENTRY real(bcd& z)
  510. {
  511.     return __bcd_tobinary(&z);
  512. }
  513.  
  514. // Definitions of compound-assignment operator member functions
  515.  
  516. inline bcd& _RTLENTRY bcd::operator+=(bcd& b)
  517. {
  518.     __bcd_todecimal(real(*this)+real(b),_BcdMaxDecimals,this);
  519.     return *this;
  520. }
  521.  
  522. inline bcd& _RTLENTRY bcd::operator+=(long double b)
  523. {
  524.     __bcd_todecimal(real(*this)+b,_BcdMaxDecimals,this);
  525.     return *this;
  526. }
  527.  
  528. inline bcd& _RTLENTRY bcd::operator-=(bcd& b)
  529. {
  530.     __bcd_todecimal(real(*this)-real(b),_BcdMaxDecimals,this);
  531.     return *this;
  532. }
  533.  
  534. inline bcd& _RTLENTRY bcd::operator-=(long double b)
  535. {
  536.     __bcd_todecimal(real(*this)-b,_BcdMaxDecimals,this);
  537.     return *this;
  538. }
  539.  
  540. inline bcd& _RTLENTRY bcd::operator*=(bcd& b)
  541. {
  542.     __bcd_todecimal(real(*this)*real(b),_BcdMaxDecimals,this);
  543.     return *this;
  544. }
  545.  
  546. inline bcd& _RTLENTRY bcd::operator*=(long double b)
  547. {
  548.     __bcd_todecimal(real(*this)*b,_BcdMaxDecimals,this);
  549.     return *this;
  550. }
  551.  
  552. inline bcd& _RTLENTRY bcd::operator/=(bcd& b)
  553. {
  554.     __bcd_todecimal(real(*this)/real(b),_BcdMaxDecimals,this);
  555.     return *this;
  556. }
  557.  
  558. inline bcd& _RTLENTRY bcd::operator/=(long double b)
  559. {
  560.     __bcd_todecimal(real(*this)/b,_BcdMaxDecimals,this);
  561.     return *this;
  562. }
  563.  
  564.  
  565. // Definitions of non-member binary operator functions
  566.  
  567. inline bcd _RTLENTRY operator+(bcd& a, bcd& b)
  568. {
  569.     return bcd(real(a) + real(b));
  570. }
  571.  
  572. inline bcd _RTLENTRY operator+(long double a, bcd& b)
  573. {
  574.     return bcd(a + real(b));
  575. }
  576.  
  577. inline bcd _RTLENTRY operator+(bcd& a, long double b)
  578. {
  579.     return bcd(real(a) + b);
  580. }
  581.  
  582. inline bcd _RTLENTRY operator-(bcd& a, bcd& b)
  583. {
  584.     return bcd(real(a) - real(b));
  585. }
  586.  
  587. inline bcd _RTLENTRY operator-(long double a, bcd& b)
  588. {
  589.     return bcd(a - real(b));
  590. }
  591.  
  592. inline bcd _RTLENTRY operator-(bcd& a, long double b)
  593. {
  594.     return bcd(real(a) - b);
  595. }
  596.  
  597. inline bcd _RTLENTRY operator*(bcd& a, bcd& b)
  598. {
  599.     return bcd(real(a) * real(b));
  600. }
  601.  
  602. inline bcd _RTLENTRY operator*(bcd& a, long double b)
  603. {
  604.     return bcd(real(a) * b);
  605. }
  606.  
  607. inline bcd _RTLENTRY operator*(long double a, bcd& b)
  608. {
  609.     return bcd(a * real(b));
  610. }
  611.  
  612. inline bcd _RTLENTRY operator/(bcd& a, bcd& b)
  613. {
  614.     return bcd(real(a) / real(b));
  615. }
  616.  
  617. inline bcd _RTLENTRY operator/(long double a, bcd& b)
  618. {
  619.     return bcd(a / real(b));
  620. }
  621.  
  622. inline bcd _RTLENTRY operator/(bcd& a, long double b)
  623. {
  624.     return bcd(real(a) / b);
  625. }
  626.  
  627. inline int _RTLENTRY operator==(bcd& a, bcd& b)
  628. {
  629.     return real(a) == real(b);
  630. }
  631.  
  632. inline int _RTLENTRY operator!=(bcd& a, bcd& b)
  633. {
  634.     return real(a) != real(b);
  635. }
  636.  
  637. inline int _RTLENTRY operator>=(bcd& a, bcd& b)
  638. {
  639.     return real(a) >= real(b);
  640. }
  641.  
  642. inline int _RTLENTRY operator<=(bcd& a, bcd& b)
  643. {
  644.     return real(a) <= real(b);
  645. }
  646.  
  647. inline int _RTLENTRY operator>(bcd& a, bcd& b)
  648. {
  649.     return real(a) > real(b);
  650. }
  651.  
  652. inline int _RTLENTRY operator<(bcd& a, bcd& b)
  653. {
  654.     return real(a) < real(b);
  655. }
  656.  
  657. inline bcd _RTLENTRY bcd::operator+()
  658. {
  659.     return *this;
  660. }
  661.  
  662. inline bcd _RTLENTRY bcd::operator-()
  663. {
  664. //  return bcd(-real(this));
  665.  
  666. // 1's comp
  667.     mantissa[0] = - ++ mantissa[0];
  668.     mantissa[1] = - ++ mantissa[1];
  669. // inc
  670.     if (++mantissa[0] == 0) ++mantissa[1];
  671.     return *this;
  672. }
  673.  
  674. inline bcd _RTLENTRY abs(bcd& a)   { return bcd(fabs(real(a)));}
  675. inline bcd _RTLENTRY acos(bcd& a)  { return bcd(acos(real(a)));}
  676. inline bcd _RTLENTRY asin(bcd& a)  { return bcd(asin(real(a)));}
  677. inline bcd _RTLENTRY atan(bcd& a)  { return bcd(atan(real(a)));}
  678. inline bcd _RTLENTRY cos(bcd& a)   { return bcd(cos(real(a)));}
  679. inline bcd _RTLENTRY cosh(bcd& a)  { return bcd(cosh(real(a)));}
  680. inline bcd _RTLENTRY exp(bcd& a)   { return bcd(exp(real(a)));}
  681. inline bcd _RTLENTRY log(bcd& a)   { return bcd(log(real(a)));}
  682. inline bcd _RTLENTRY log10(bcd& a) { return bcd(__bcd_log10(&a));}
  683. inline bcd _RTLENTRY sin(bcd& a)   { return bcd(sin(real(a)));}
  684. inline bcd _RTLENTRY sinh(bcd& a)  { return bcd(sinh(real(a)));}
  685. inline bcd _RTLENTRY sqrt(bcd& a)  { return bcd(sqrt(real(a)));}
  686. inline bcd _RTLENTRY tan(bcd& a)   { return bcd(tan(real(a)));}
  687. inline bcd _RTLENTRY tanh(bcd& a)  { return bcd(tanh(real(a)));}
  688.  
  689. inline bcd _RTLENTRY pow(bcd& a, bcd& b)   { return bcd(pow(real(a),real(b)));}
  690. inline void _RTLENTRY pow10(int n, bcd& a) { __bcd_pow10(n,&a);}
  691.  
  692. // bcd stream I/O
  693.  
  694. #if !defined( __IOSTREAM_H )
  695. #include <iostream.h>
  696. #endif
  697.  
  698. #if !defined(RC_INVOKED)
  699. #pragma option -a-     /* Assume byte packing  */
  700. #endif
  701.  
  702. ostream & _RTLENTRY _EXPFUNC operator<<(ostream &, bcd &);
  703. istream & _RTLENTRY _EXPFUNC operator>>(istream &, bcd &);
  704.  
  705. #if !defined(RC_INVOKED)
  706. #pragma option -a.  /* revert to default packing  */
  707. #endif
  708.  
  709. #endif  /* __FLAT__  */
  710.  
  711. #endif  // __BCD_H
  712.  
  713.  
  714.