math.c 7.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459
  1. /* x87-backed math for the ring-3 libc.
  2. *
  3. * The target is i586 with -mno-sse, so double arithmetic is x87 anyway. The
  4. * transcendental routines use the x87 instructions with an explicit range
  5. * reduction for the trigonometric functions. Accuracy is a double-rounding
  6. * compromise, not a full fdlibm port. */
  7. #include <math.h>
  8. #include <float.h>
  9. #define PI 3.14159265358979323846
  10. #define LOG2E 1.44269504088896340736
  11. #define LN2 0.69314718055994530942
  12. static double round_mode(double x, unsigned int mode)
  13. {
  14. unsigned short cw, old;
  15. double r;
  16. if (__builtin_isnan(x) || __builtin_isinf(x) || x == 0.0)
  17. return x;
  18. __asm__ volatile ("fnstcw %0" : "=m"(cw));
  19. old = cw;
  20. cw = (unsigned short)((cw & ~0x0C00u) | (mode << 10));
  21. __asm__ volatile ("fldcw %0" : : "m"(cw));
  22. __asm__ volatile ("fldl %1; frndint; fstpl %0" : "=m"(r) : "m"(x));
  23. __asm__ volatile ("fldcw %0" : : "m"(old));
  24. return r;
  25. }
  26. double fabs(double x)
  27. {
  28. union {
  29. double d;
  30. unsigned long long u;
  31. } v;
  32. v.d = x;
  33. v.u &= 0x7fffffffffffffffULL;
  34. return v.d;
  35. }
  36. double floor(double x)
  37. {
  38. return round_mode(x, 1);
  39. }
  40. double ceil(double x)
  41. {
  42. return round_mode(x, 2);
  43. }
  44. double trunc(double x)
  45. {
  46. return round_mode(x, 3);
  47. }
  48. double round(double x)
  49. {
  50. if (__builtin_isnan(x) || __builtin_isinf(x))
  51. return x;
  52. /* Above 2^52 every double is already an integer. */
  53. if (fabs(x) >= 4503599627370496.0)
  54. return x;
  55. if (x >= 0.0)
  56. return floor(x + 0.5);
  57. return ceil(x - 0.5);
  58. }
  59. double sqrt(double x)
  60. {
  61. double r;
  62. __asm__ volatile ("fldl %1; fsqrt; fstpl %0" : "=m"(r) : "m"(x));
  63. return r;
  64. }
  65. double fmod(double x, double y)
  66. {
  67. double r;
  68. __asm__ volatile (
  69. "fldl %2\n\t"
  70. "fldl %1\n\t"
  71. "1:\n\t"
  72. "fprem\n\t"
  73. "fnstsw %%ax\n\t"
  74. "testw $0x400, %%ax\n\t"
  75. "jnz 1b\n\t"
  76. "fstp %%st(1)\n\t"
  77. "fstpl %0"
  78. : "=m"(r) : "m"(x), "m"(y) : "ax");
  79. return r;
  80. }
  81. double log(double x)
  82. {
  83. double r;
  84. __asm__ volatile ("fldln2; fldl %1; fyl2x; fstpl %0"
  85. : "=m"(r) : "m"(x));
  86. return r;
  87. }
  88. double log10(double x)
  89. {
  90. double r;
  91. __asm__ volatile ("fldlg2; fldl %1; fyl2x; fstpl %0"
  92. : "=m"(r) : "m"(x));
  93. return r;
  94. }
  95. double ldexp(double x, int exp)
  96. {
  97. double r;
  98. __asm__ volatile (
  99. "fildl %1\n\t"
  100. "fldl %2\n\t"
  101. "fscale\n\t"
  102. "fstp %%st(1)\n\t"
  103. "fstpl %0"
  104. : "=m"(r) : "m"(exp), "m"(x));
  105. return r;
  106. }
  107. double exp(double x)
  108. {
  109. double y, n, f, p;
  110. if (__builtin_isnan(x))
  111. return x;
  112. if (x > 709.782712893384)
  113. return INFINITY;
  114. if (x < -745.133219101941)
  115. return 0.0;
  116. y = x * LOG2E;
  117. n = floor(y);
  118. f = y - n;
  119. __asm__ volatile ("fldl %1; f2xm1; fld1; faddp; fstpl %0"
  120. : "=m"(p) : "m"(f));
  121. return ldexp(p, (int)n);
  122. }
  123. double pow(double x, double y)
  124. {
  125. int neg = 0;
  126. double r;
  127. if (y == 0.0)
  128. return 1.0;
  129. if (x == 1.0)
  130. return 1.0;
  131. if (__builtin_isnan(x) || __builtin_isnan(y))
  132. return NAN;
  133. if (x == 0.0) {
  134. if (y < 0.0)
  135. return INFINITY;
  136. return 0.0;
  137. }
  138. if (x < 0.0) {
  139. double yi = floor(y);
  140. if (yi != y)
  141. return NAN;
  142. x = -x;
  143. if (fmod(yi, 2.0) != 0.0)
  144. neg = 1;
  145. }
  146. /* Small integer powers are common in JavaScript and stay exact. */
  147. if (y == floor(y) && y >= -64.0 && y <= 64.0) {
  148. int n = (int)y;
  149. int e = n < 0 ? -n : n;
  150. r = 1.0;
  151. while (e) {
  152. if (e & 1)
  153. r *= x;
  154. x *= x;
  155. e >>= 1;
  156. }
  157. if (n < 0)
  158. r = 1.0 / r;
  159. } else {
  160. r = exp(y * log(x));
  161. }
  162. return neg ? -r : r;
  163. }
  164. double sin(double x)
  165. {
  166. double r;
  167. /* The x87 reduction uses a 66-bit pi internally; pre-reducing with a
  168. * double 2*pi would lose more phase for large arguments. */
  169. __asm__ volatile ("fldl %1; fsin; fstpl %0" : "=m"(r) : "m"(x));
  170. return r;
  171. }
  172. double cos(double x)
  173. {
  174. double r;
  175. __asm__ volatile ("fldl %1; fcos; fstpl %0" : "=m"(r) : "m"(x));
  176. return r;
  177. }
  178. double tan(double x)
  179. {
  180. double r;
  181. __asm__ volatile ("fldl %1; fptan; fstp %%st(0); fstpl %0"
  182. : "=m"(r) : "m"(x));
  183. return r;
  184. }
  185. double atan(double x)
  186. {
  187. double r;
  188. __asm__ volatile ("fldl %1; fld1; fpatan; fstpl %0"
  189. : "=m"(r) : "m"(x));
  190. return r;
  191. }
  192. double atan2(double y, double x)
  193. {
  194. double r;
  195. __asm__ volatile ("fldl %1; fldl %2; fpatan; fstpl %0"
  196. : "=m"(r) : "m"(y), "m"(x));
  197. return r;
  198. }
  199. double asin(double x)
  200. {
  201. if (x > 1.0 || x < -1.0)
  202. return NAN;
  203. return atan2(x, sqrt(1.0 - x * x));
  204. }
  205. double acos(double x)
  206. {
  207. if (x > 1.0 || x < -1.0)
  208. return NAN;
  209. return atan2(sqrt(1.0 - x * x), x);
  210. }
  211. double fmin(double x, double y)
  212. {
  213. if (__builtin_isnan(x))
  214. return y;
  215. if (__builtin_isnan(y))
  216. return x;
  217. return x < y ? x : y;
  218. }
  219. double fmax(double x, double y)
  220. {
  221. if (__builtin_isnan(x))
  222. return y;
  223. if (__builtin_isnan(y))
  224. return x;
  225. return x > y ? x : y;
  226. }
  227. double copysign(double x, double y)
  228. {
  229. union {
  230. double d;
  231. unsigned long long u;
  232. } a, b;
  233. a.d = x;
  234. b.d = y;
  235. a.u = (a.u & 0x7fffffffffffffffULL) |
  236. (b.u & 0x8000000000000000ULL);
  237. return a.d;
  238. }
  239. double frexp(double x, int *exp)
  240. {
  241. union {
  242. double d;
  243. unsigned long long u;
  244. } v;
  245. unsigned long long bits;
  246. unsigned int e;
  247. int extra = 0;
  248. if (__builtin_isnan(x) || __builtin_isinf(x) || x == 0.0) {
  249. if (exp)
  250. *exp = 0;
  251. return x;
  252. }
  253. if (fabs(x) < DBL_MIN) {
  254. x *= 18446744073709551616.0; /* 2^64 */
  255. extra = 64;
  256. }
  257. v.d = x;
  258. bits = v.u;
  259. e = (unsigned int)((bits >> 52) & 0x7ffu);
  260. if (exp)
  261. *exp = (int)e - 1022 - extra;
  262. bits = (bits & 0x800fffffffffffffULL) | (1022ULL << 52);
  263. v.u = bits;
  264. return v.d;
  265. }
  266. double modf(double x, double *iptr)
  267. {
  268. double ip = trunc(x);
  269. if (iptr)
  270. *iptr = ip;
  271. return x - ip;
  272. }
  273. /* ---- C99 additions used by QuickJS's Math object ---- */
  274. #define M_LN2_D 0.69314718055994530942
  275. double hypot(double x, double y)
  276. {
  277. double a = fabs(x), b = fabs(y), r;
  278. if (__builtin_isinf(a) || __builtin_isinf(b))
  279. return INFINITY;
  280. if (__builtin_isnan(a) || __builtin_isnan(b))
  281. return NAN;
  282. if (a < b) {
  283. r = a;
  284. a = b;
  285. b = r;
  286. }
  287. if (a == 0.0)
  288. return 0.0;
  289. r = b / a;
  290. return a * sqrt(1.0 + r * r);
  291. }
  292. double cbrt(double x)
  293. {
  294. double a = fabs(x), y;
  295. if (a == 0.0 || __builtin_isinf(a) || __builtin_isnan(a))
  296. return x;
  297. y = pow(a, 1.0 / 3.0);
  298. y = y - (y * y * y - a) / (3.0 * y * y); /* one Newton step */
  299. return x < 0 ? -y : y;
  300. }
  301. double log2(double x)
  302. {
  303. int e;
  304. double m;
  305. if (!(x > 0.0) || __builtin_isinf(x))
  306. return log(x) / M_LN2_D;
  307. m = frexp(x, &e); /* x = m * 2^e, m in [0.5, 1) */
  308. if (m == 0.5)
  309. return (double)(e - 1);
  310. return (double)e + log(m) / M_LN2_D;
  311. }
  312. double log1p(double x)
  313. {
  314. double u;
  315. if (fabs(x) < 1e-4)
  316. return x - x * x / 2.0 + x * x * x / 3.0;
  317. u = 1.0 + x;
  318. if (u == 1.0)
  319. return x;
  320. return log(u) - ((u - 1.0) - x) / u;
  321. }
  322. double expm1(double x)
  323. {
  324. double u, um1;
  325. if (fabs(x) < 1e-5)
  326. return x + x * x / 2.0 + x * x * x / 6.0;
  327. u = exp(x);
  328. if (u == 1.0)
  329. return x;
  330. um1 = u - 1.0;
  331. if (um1 == -1.0)
  332. return -1.0;
  333. if (__builtin_isinf(u))
  334. return u;
  335. return um1 * x / log(u);
  336. }
  337. double sinh(double x)
  338. {
  339. double t = expm1(fabs(x)), s;
  340. s = 0.5 * (t + t / (t + 1.0));
  341. return x < 0 ? -s : s;
  342. }
  343. double cosh(double x)
  344. {
  345. double e = exp(fabs(x));
  346. return 0.5 * (e + 1.0 / e);
  347. }
  348. double tanh(double x)
  349. {
  350. double a = fabs(x), t, r;
  351. if (a > 22.0)
  352. r = 1.0;
  353. else {
  354. t = expm1(2.0 * a);
  355. r = t / (t + 2.0);
  356. }
  357. return x < 0 ? -r : r;
  358. }
  359. double asinh(double x)
  360. {
  361. double a = fabs(x), r;
  362. r = log1p(a + a * a / (1.0 + sqrt(1.0 + a * a)));
  363. return x < 0 ? -r : r;
  364. }
  365. double acosh(double x)
  366. {
  367. if (x < 1.0)
  368. return NAN;
  369. return log(x + sqrt(x * x - 1.0));
  370. }
  371. double atanh(double x)
  372. {
  373. double a = fabs(x), r;
  374. if (a > 1.0)
  375. return NAN;
  376. r = 0.5 * log1p(2.0 * a / (1.0 - a));
  377. return x < 0 ? -r : r;
  378. }
  379. /* Round to nearest, ties to even (the default rounding mode). */
  380. long lrint(double x)
  381. {
  382. double r = round(x);
  383. if (fabs(x - trunc(x)) == 0.5 && fmod(r, 2.0) != 0.0)
  384. r -= x < 0 ? -1.0 : 1.0;
  385. return (long)r;
  386. }