9
3

lmathlib.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410
  1. /*
  2. ** $Id: lmathlib.c,v 1.119 2016/12/22 13:08:50 roberto Exp $
  3. ** Standard mathematical library
  4. ** See Copyright Notice in lua.h
  5. */
  6. #define lmathlib_c
  7. #define LUA_LIB
  8. #include "lprefix.h"
  9. #include <stdlib.h>
  10. #include <math.h>
  11. #include "lua.h"
  12. #include "lauxlib.h"
  13. #include "lualib.h"
  14. #undef PI
  15. #define PI (l_mathop(3.141592653589793238462643383279502884))
  16. #if !defined(l_rand) /* { */
  17. #if defined(LUA_USE_POSIX)
  18. #define l_rand() random()
  19. #define l_srand(x) srandom(x)
  20. #define L_RANDMAX 2147483647 /* (2^31 - 1), following POSIX */
  21. #else
  22. #define l_rand() rand()
  23. #define l_srand(x) srand(x)
  24. #define L_RANDMAX RAND_MAX
  25. #endif
  26. #endif /* } */
  27. static int math_abs (lua_State *L) {
  28. if (lua_isinteger(L, 1)) {
  29. lua_Integer n = lua_tointeger(L, 1);
  30. if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
  31. lua_pushinteger(L, n);
  32. }
  33. else
  34. lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
  35. return 1;
  36. }
  37. static int math_sin (lua_State *L) {
  38. lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
  39. return 1;
  40. }
  41. static int math_cos (lua_State *L) {
  42. lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
  43. return 1;
  44. }
  45. static int math_tan (lua_State *L) {
  46. lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
  47. return 1;
  48. }
  49. static int math_asin (lua_State *L) {
  50. lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
  51. return 1;
  52. }
  53. static int math_acos (lua_State *L) {
  54. lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
  55. return 1;
  56. }
  57. static int math_atan (lua_State *L) {
  58. lua_Number y = luaL_checknumber(L, 1);
  59. lua_Number x = luaL_optnumber(L, 2, 1);
  60. lua_pushnumber(L, l_mathop(atan2)(y, x));
  61. return 1;
  62. }
  63. static int math_toint (lua_State *L) {
  64. int valid;
  65. lua_Integer n = lua_tointegerx(L, 1, &valid);
  66. if (valid)
  67. lua_pushinteger(L, n);
  68. else {
  69. luaL_checkany(L, 1);
  70. lua_pushnil(L); /* value is not convertible to integer */
  71. }
  72. return 1;
  73. }
  74. static void pushnumint (lua_State *L, lua_Number d) {
  75. lua_Integer n;
  76. if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */
  77. lua_pushinteger(L, n); /* result is integer */
  78. else
  79. lua_pushnumber(L, d); /* result is float */
  80. }
  81. static int math_floor (lua_State *L) {
  82. if (lua_isinteger(L, 1))
  83. lua_settop(L, 1); /* integer is its own floor */
  84. else {
  85. lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
  86. pushnumint(L, d);
  87. }
  88. return 1;
  89. }
  90. static int math_ceil (lua_State *L) {
  91. if (lua_isinteger(L, 1))
  92. lua_settop(L, 1); /* integer is its own ceil */
  93. else {
  94. lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
  95. pushnumint(L, d);
  96. }
  97. return 1;
  98. }
  99. static int math_fmod (lua_State *L) {
  100. if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
  101. lua_Integer d = lua_tointeger(L, 2);
  102. if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
  103. luaL_argcheck(L, d != 0, 2, "zero");
  104. lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
  105. }
  106. else
  107. lua_pushinteger(L, lua_tointeger(L, 1) % d);
  108. }
  109. else
  110. lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
  111. luaL_checknumber(L, 2)));
  112. return 1;
  113. }
  114. /*
  115. ** next function does not use 'modf', avoiding problems with 'double*'
  116. ** (which is not compatible with 'float*') when lua_Number is not
  117. ** 'double'.
  118. */
  119. static int math_modf (lua_State *L) {
  120. if (lua_isinteger(L ,1)) {
  121. lua_settop(L, 1); /* number is its own integer part */
  122. lua_pushnumber(L, 0); /* no fractional part */
  123. }
  124. else {
  125. lua_Number n = luaL_checknumber(L, 1);
  126. /* integer part (rounds toward zero) */
  127. lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
  128. pushnumint(L, ip);
  129. /* fractional part (test needed for inf/-inf) */
  130. lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
  131. }
  132. return 2;
  133. }
  134. static int math_sqrt (lua_State *L) {
  135. lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
  136. return 1;
  137. }
  138. static int math_ult (lua_State *L) {
  139. lua_Integer a = luaL_checkinteger(L, 1);
  140. lua_Integer b = luaL_checkinteger(L, 2);
  141. lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
  142. return 1;
  143. }
  144. static int math_log (lua_State *L) {
  145. lua_Number x = luaL_checknumber(L, 1);
  146. lua_Number res;
  147. if (lua_isnoneornil(L, 2))
  148. res = l_mathop(log)(x);
  149. else {
  150. lua_Number base = luaL_checknumber(L, 2);
  151. #if !defined(LUA_USE_C89)
  152. if (base == l_mathop(2.0))
  153. res = l_mathop(log2)(x); else
  154. #endif
  155. if (base == l_mathop(10.0))
  156. res = l_mathop(log10)(x);
  157. else
  158. res = l_mathop(log)(x)/l_mathop(log)(base);
  159. }
  160. lua_pushnumber(L, res);
  161. return 1;
  162. }
  163. static int math_exp (lua_State *L) {
  164. lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
  165. return 1;
  166. }
  167. static int math_deg (lua_State *L) {
  168. lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
  169. return 1;
  170. }
  171. static int math_rad (lua_State *L) {
  172. lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
  173. return 1;
  174. }
  175. static int math_min (lua_State *L) {
  176. int n = lua_gettop(L); /* number of arguments */
  177. int imin = 1; /* index of current minimum value */
  178. int i;
  179. luaL_argcheck(L, n >= 1, 1, "value expected");
  180. for (i = 2; i <= n; i++) {
  181. if (lua_compare(L, i, imin, LUA_OPLT))
  182. imin = i;
  183. }
  184. lua_pushvalue(L, imin);
  185. return 1;
  186. }
  187. static int math_max (lua_State *L) {
  188. int n = lua_gettop(L); /* number of arguments */
  189. int imax = 1; /* index of current maximum value */
  190. int i;
  191. luaL_argcheck(L, n >= 1, 1, "value expected");
  192. for (i = 2; i <= n; i++) {
  193. if (lua_compare(L, imax, i, LUA_OPLT))
  194. imax = i;
  195. }
  196. lua_pushvalue(L, imax);
  197. return 1;
  198. }
  199. /*
  200. ** This function uses 'double' (instead of 'lua_Number') to ensure that
  201. ** all bits from 'l_rand' can be represented, and that 'RANDMAX + 1.0'
  202. ** will keep full precision (ensuring that 'r' is always less than 1.0.)
  203. */
  204. static int math_random (lua_State *L) {
  205. lua_Integer low, up;
  206. double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0));
  207. switch (lua_gettop(L)) { /* check number of arguments */
  208. case 0: { /* no arguments */
  209. lua_pushnumber(L, (lua_Number)r); /* Number between 0 and 1 */
  210. return 1;
  211. }
  212. case 1: { /* only upper limit */
  213. low = 1;
  214. up = luaL_checkinteger(L, 1);
  215. break;
  216. }
  217. case 2: { /* lower and upper limits */
  218. low = luaL_checkinteger(L, 1);
  219. up = luaL_checkinteger(L, 2);
  220. break;
  221. }
  222. default: return luaL_error(L, "wrong number of arguments");
  223. }
  224. /* random integer in the interval [low, up] */
  225. luaL_argcheck(L, low <= up, 1, "interval is empty");
  226. luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
  227. "interval too large");
  228. r *= (double)(up - low) + 1.0;
  229. lua_pushinteger(L, (lua_Integer)r + low);
  230. return 1;
  231. }
  232. static int math_randomseed (lua_State *L) {
  233. l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
  234. (void)l_rand(); /* discard first value to avoid undesirable correlations */
  235. return 0;
  236. }
  237. static int math_type (lua_State *L) {
  238. if (lua_type(L, 1) == LUA_TNUMBER) {
  239. if (lua_isinteger(L, 1))
  240. lua_pushliteral(L, "integer");
  241. else
  242. lua_pushliteral(L, "float");
  243. }
  244. else {
  245. luaL_checkany(L, 1);
  246. lua_pushnil(L);
  247. }
  248. return 1;
  249. }
  250. /*
  251. ** {==================================================================
  252. ** Deprecated functions (for compatibility only)
  253. ** ===================================================================
  254. */
  255. #if defined(LUA_COMPAT_MATHLIB)
  256. static int math_cosh (lua_State *L) {
  257. lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
  258. return 1;
  259. }
  260. static int math_sinh (lua_State *L) {
  261. lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
  262. return 1;
  263. }
  264. static int math_tanh (lua_State *L) {
  265. lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
  266. return 1;
  267. }
  268. static int math_pow (lua_State *L) {
  269. lua_Number x = luaL_checknumber(L, 1);
  270. lua_Number y = luaL_checknumber(L, 2);
  271. lua_pushnumber(L, l_mathop(pow)(x, y));
  272. return 1;
  273. }
  274. static int math_frexp (lua_State *L) {
  275. int e;
  276. lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
  277. lua_pushinteger(L, e);
  278. return 2;
  279. }
  280. static int math_ldexp (lua_State *L) {
  281. lua_Number x = luaL_checknumber(L, 1);
  282. int ep = (int)luaL_checkinteger(L, 2);
  283. lua_pushnumber(L, l_mathop(ldexp)(x, ep));
  284. return 1;
  285. }
  286. static int math_log10 (lua_State *L) {
  287. lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
  288. return 1;
  289. }
  290. #endif
  291. /* }================================================================== */
  292. static const luaL_Reg mathlib[] = {
  293. {"abs", math_abs},
  294. {"acos", math_acos},
  295. {"asin", math_asin},
  296. {"atan", math_atan},
  297. {"ceil", math_ceil},
  298. {"cos", math_cos},
  299. {"deg", math_deg},
  300. {"exp", math_exp},
  301. {"tointeger", math_toint},
  302. {"floor", math_floor},
  303. {"fmod", math_fmod},
  304. {"ult", math_ult},
  305. {"log", math_log},
  306. {"max", math_max},
  307. {"min", math_min},
  308. {"modf", math_modf},
  309. {"rad", math_rad},
  310. {"random", math_random},
  311. {"randomseed", math_randomseed},
  312. {"sin", math_sin},
  313. {"sqrt", math_sqrt},
  314. {"tan", math_tan},
  315. {"type", math_type},
  316. #if defined(LUA_COMPAT_MATHLIB)
  317. {"atan2", math_atan},
  318. {"cosh", math_cosh},
  319. {"sinh", math_sinh},
  320. {"tanh", math_tanh},
  321. {"pow", math_pow},
  322. {"frexp", math_frexp},
  323. {"ldexp", math_ldexp},
  324. {"log10", math_log10},
  325. #endif
  326. /* placeholders */
  327. {"pi", NULL},
  328. {"huge", NULL},
  329. {"maxinteger", NULL},
  330. {"mininteger", NULL},
  331. {NULL, NULL}
  332. };
  333. /*
  334. ** Open math library
  335. */
  336. LUAMOD_API int luaopen_math (lua_State *L) {
  337. luaL_newlib(L, mathlib);
  338. lua_pushnumber(L, PI);
  339. lua_setfield(L, -2, "pi");
  340. lua_pushnumber(L, (lua_Number)HUGE_VAL);
  341. lua_setfield(L, -2, "huge");
  342. lua_pushinteger(L, LUA_MAXINTEGER);
  343. lua_setfield(L, -2, "maxinteger");
  344. lua_pushinteger(L, LUA_MININTEGER);
  345. lua_setfield(L, -2, "mininteger");
  346. return 1;
  347. }