home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Programming / jikes-1.02 / src / double.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-08-20  |  8.2 KB  |  344 lines
  1. // $Id: double.cpp,v 1.6 1999/08/20 14:44:21 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include <iostream.h>
  12. #include "double.h"
  13. #include "long.h"
  14.  
  15. IEEEdouble IEEEdouble::min_long = IEEEdouble(0xc3e00000, 0x00000000);
  16.  
  17. IEEEfloat::IEEEfloat(float d)
  18. {
  19.     FloatValue() = d;
  20. }
  21.  
  22. IEEEfloat::IEEEfloat(u4 a)
  23. {
  24.     Word() = a;
  25. }
  26.  
  27. IEEEfloat::IEEEfloat(i4 a)
  28. {
  29.     FloatValue() = a;
  30. }
  31.  
  32. IEEEfloat::IEEEfloat(char * name)
  33. {
  34.     FloatValue() = atof(name);
  35. }
  36.  
  37. int IEEEfloat::IntValue()
  38. {
  39.     return (int) FloatValue();
  40. }
  41. int IEEEfloat::LongValue()
  42. {
  43.     return (long) FloatValue();
  44. }
  45.  
  46. IEEEdouble::IEEEdouble(double d)
  47. {
  48.     DoubleValue() = d;
  49. }
  50.  
  51. IEEEdouble::IEEEdouble(u4 a, u4 b)
  52. {
  53.     HighWord() = a;
  54.     LowWord() = b;
  55. }
  56.  
  57. IEEEdouble::IEEEdouble(IEEEfloat a)
  58. {
  59.     DoubleValue() = a.FloatValue();
  60. }
  61.  
  62. IEEEdouble::IEEEdouble(i4 a)
  63. {
  64.     DoubleValue() = a;
  65. }
  66.  
  67.  
  68. IEEEdouble::IEEEdouble(u4 a)
  69. {
  70.     HighWord() = 0;
  71.     LowWord() = a;
  72. }
  73.  
  74. IEEEdouble::IEEEdouble(char * name)
  75. {
  76.     DoubleValue()  = atof(name);
  77. }
  78.  
  79. bool IEEEdouble::operator== (IEEEdouble op)
  80. {
  81.     return DoubleValue() == op.DoubleValue();
  82. }
  83.  
  84. bool IEEEdouble::operator!= (IEEEdouble op)
  85. {
  86.     return DoubleValue() != op.DoubleValue();
  87. }
  88.  
  89. IEEEdouble IEEEdouble::operator+ (IEEEdouble op)
  90. {
  91.     return IEEEdouble(DoubleValue() + op.DoubleValue());
  92. }
  93.  
  94. IEEEdouble& IEEEdouble::operator+= (IEEEdouble op)
  95. {
  96.     *this = *this + op;
  97.     return *this;
  98. }
  99.  
  100. IEEEdouble IEEEdouble::operator- ()
  101. {
  102.     return IEEEdouble(- this -> DoubleValue());
  103. }
  104.  
  105. IEEEdouble IEEEdouble::operator- (IEEEdouble op)
  106. {
  107.     return IEEEdouble(DoubleValue() + (-op.DoubleValue()));
  108. }
  109.  
  110. IEEEdouble& IEEEdouble::operator-= (IEEEdouble op)
  111. {
  112.     *this = *this - op;
  113.     return *this;
  114. }
  115.  
  116.  
  117. IEEEdouble IEEEdouble::operator* (IEEEdouble op)
  118. {
  119.     return IEEEdouble(DoubleValue() * op.DoubleValue());
  120. }
  121.  
  122. IEEEdouble& IEEEdouble::operator*= (IEEEdouble op)
  123. {
  124.     *this = *this * op;
  125.     return *this;
  126. }
  127.  
  128. IEEEdouble IEEEdouble::operator/ (IEEEdouble op)
  129. {
  130. #ifndef IEEE_DIV_0
  131.     return IEEEdouble(DoubleValue() / op.DoubleValue());
  132. #else /* IEEE_DIV_0 */
  133.     return (op.DoubleValue() == 0.0
  134.                               ? (DoubleValue() < 0.0
  135.                                                ? NEGATIVE_INFINITY()
  136.                                                : DoubleValue() == 0.0
  137.                                                                 ? NaN()
  138.                                                                 : POSITIVE_INFINITY())
  139.                               : IEEEdouble(DoubleValue() / op.DoubleValue()));
  140. #endif /* IEEE_DIV_0 */
  141. }
  142.  
  143. IEEEdouble& IEEEdouble::operator/= (IEEEdouble op)
  144. {
  145. #ifndef IEEE_DIV_0
  146.     *this = *this / op;
  147. #else /* IEEE_DIV_0 */
  148.     *this = (op.DoubleValue() == 0.0
  149.                                ? (*this < 0.0
  150.                                         ? NEGATIVE_INFINITY()
  151.                                         : *this == 0.0
  152.                                                  ? NaN()
  153.                                                  : POSITIVE_INFINITY())
  154.                                : *this / op);
  155. #endif /* IEEE_DIV_0 */
  156.  
  157.     return *this;
  158. }
  159.  
  160. bool IEEEdouble::operator< (IEEEdouble op)
  161. {
  162.     return (DoubleValue() < op.DoubleValue() ? 1 : 0);
  163. }
  164.  
  165. bool IEEEdouble::operator<= (IEEEdouble op)
  166. {
  167.     return (DoubleValue() <= op.DoubleValue() ? 1 : 0);
  168. }
  169.  
  170. bool IEEEdouble::operator> (IEEEdouble op)
  171. {
  172.     return (DoubleValue() > op.DoubleValue() ? 1 : 0);
  173. }
  174.  
  175. bool IEEEdouble::operator>= (IEEEdouble op)
  176. {
  177.     return (DoubleValue() >= op.DoubleValue() ? 1 : 0);
  178. }
  179.  
  180. bool IEEEfloat::operator== (IEEEfloat op)
  181. {
  182.     return FloatValue() == op.FloatValue();
  183. }
  184.  
  185. bool IEEEfloat::operator!= (IEEEfloat op)
  186. {
  187.     return FloatValue() != op.FloatValue();
  188. }
  189.  
  190.  
  191. bool IEEEfloat::operator< (IEEEfloat op)
  192. {
  193.     return (FloatValue() < op.FloatValue() ? 1 : 0);
  194. }
  195.  
  196. bool IEEEfloat::operator<= (IEEEfloat op)
  197. {
  198.     return (FloatValue() <= op.FloatValue() ? 1 : 0);
  199. }
  200.  
  201. bool IEEEfloat::operator> (IEEEfloat op)
  202. {
  203.     return (FloatValue() > op.FloatValue() ? 1 : 0);
  204. }
  205.  
  206. bool IEEEfloat::operator>= (IEEEfloat op)
  207. {
  208.     return (FloatValue() >= op.FloatValue() ? 1 : 0);
  209. }
  210.  
  211.  
  212. IEEEfloat IEEEfloat::operator+ (IEEEfloat op)
  213. {
  214.     return IEEEfloat(FloatValue() + op.FloatValue());
  215. }
  216.  
  217. IEEEfloat& IEEEfloat::operator+= (IEEEfloat op)
  218. {
  219.     *this = *this + op;
  220.     return *this;
  221. }
  222.  
  223.  
  224. IEEEfloat IEEEfloat::operator- ()
  225. {
  226.     return IEEEfloat( - this -> FloatValue());
  227.  
  228. }
  229.  
  230. IEEEfloat IEEEfloat::operator- (IEEEfloat op)
  231. {
  232.     return *this + (-op);
  233. }
  234.  
  235. IEEEfloat& IEEEfloat::operator-= (IEEEfloat op)
  236. {
  237.     *this = *this - op;
  238.     return *this;
  239. }
  240.  
  241. IEEEfloat IEEEfloat::operator* (IEEEfloat op)
  242. {
  243.     return IEEEfloat(FloatValue() * op.FloatValue());
  244. }
  245.  
  246. IEEEfloat& IEEEfloat::operator*= (IEEEfloat op)
  247. {
  248.     *this = *this * op;
  249.     return *this;
  250. }
  251.  
  252. IEEEfloat IEEEfloat::operator/ (IEEEfloat op)
  253. {
  254. #ifndef IEEE_DIV_0
  255.     return IEEEfloat(FloatValue() / op.FloatValue());
  256. #else /* IEEE_DIV_0 */
  257.     return (op.FloatValue() == 0.0
  258.                              ? (FloatValue() < 0.0
  259.                                              ? IEEEfloat(IEEEdouble::NEGATIVE_INFINITY())
  260.                                              : FloatValue() == 0.0
  261.                                                              ? IEEEfloat(IEEEdouble::NaN())
  262.                                                              : IEEEfloat(IEEEdouble::POSITIVE_INFINITY()))
  263.                              : IEEEfloat(FloatValue() / op.FloatValue()));
  264. #endif /* IEEE_DIV_0 */
  265. }
  266.  
  267. IEEEfloat& IEEEfloat::operator/= (IEEEfloat op)
  268. {
  269. #ifndef IEEE_DIV_0
  270.     *this = *this / op;
  271. #else /* IEEE_DIV_0 */
  272.     *this = (op.FloatValue() == 0.0
  273.                               ? (*this < (float) 0.0
  274.                                        ? IEEEdouble::NEGATIVE_INFINITY()
  275.                                        : *this == (float) 0.0
  276.                                                 ? IEEEdouble::NaN()
  277.                                                 : IEEEdouble::POSITIVE_INFINITY())
  278.                               : *this / op);
  279. #endif /* IEEE_DIV_0 */
  280.  
  281.     return *this;
  282. }
  283.  
  284.  
  285. void IEEEdouble::Fmodulus(IEEEdouble a, IEEEdouble b, IEEEdouble& result)
  286. {
  287. #ifndef IEEE_DIV_0
  288.      result.DoubleValue() = fmod(a.DoubleValue(), b.DoubleValue());
  289. #else /* IEEE_DIV_0 */
  290.     result.DoubleValue() = (b.DoubleValue() == 0 ? NaN().DoubleValue()
  291.                                                  : fmod(a.DoubleValue(), b.DoubleValue()));
  292. #endif /* IEEE_DIV_0 */
  293. }
  294.  
  295. void IEEEdouble::Divide(IEEEdouble dividend, IEEEdouble divisor, IEEEdouble "ient)
  296. {
  297. #ifndef IEEE_DIV_0
  298.     quotient = dividend.DoubleValue() / divisor.DoubleValue();
  299. #else /* IEEE_DIV_0 */
  300.     quotient = (divisor.DoubleValue() == 0
  301.                                        ? (dividend.DoubleValue() < 0.0
  302.                                                                  ? NEGATIVE_INFINITY()
  303.                                                                  : dividend.DoubleValue() == 0.0
  304.                                                                                            ? NaN()
  305.                                                                                            : POSITIVE_INFINITY())
  306.                                        : dividend.DoubleValue() / divisor.DoubleValue());
  307. #endif /* IEEE_DIV_0 */
  308.  
  309.     return;
  310. }
  311.  
  312. IEEEfloat::IEEEfloat(IEEEdouble a)
  313. {
  314.     FloatValue() = a.DoubleValue();
  315. }
  316.  
  317. IEEEdouble::IEEEdouble(LongInt& a)
  318. {
  319.     DoubleValue() = a.Double();
  320. }
  321.  
  322. void IEEEfloat::Fmodulus(IEEEfloat a, IEEEfloat b, IEEEfloat& result)
  323. {
  324. #ifndef IEEE_DIV_0
  325.     result.FloatValue() = (float) fmod((double) a.FloatValue(), (double) b.FloatValue());
  326. #else /* IEEE_DIV_0 */
  327.     result.FloatValue() = (b.FloatValue() == 0.0 ? (IEEEdouble::NaN()).DoubleValue()
  328.                                                  : fmod((double) a.FloatValue(), (double) b.FloatValue()));
  329. #endif /* IEEE_DIV_0 */
  330.  
  331.     return;
  332. }
  333.  
  334. void IEEEfloat::String(char * str)
  335. {
  336.     // format value into character string
  337.     sprintf(str, "%E", FloatValue());
  338. }
  339. void IEEEdouble::String(char * str)
  340. {
  341.     // format value into character string
  342.     sprintf(str, "%E", DoubleValue());
  343. }
  344.