MathObject.cpp 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318
  1. /*
  2. * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted provided that the following conditions are met:
  8. *
  9. * 1. Redistributions of source code must retain the above copyright notice, this
  10. * list of conditions and the following disclaimer.
  11. *
  12. * 2. Redistributions in binary form must reproduce the above copyright notice,
  13. * this list of conditions and the following disclaimer in the documentation
  14. * and/or other materials provided with the distribution.
  15. *
  16. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26. */
  27. #include <AK/FlyString.h>
  28. #include <AK/Function.h>
  29. #include <LibJS/Interpreter.h>
  30. #include <LibJS/Runtime/GlobalObject.h>
  31. #include <LibJS/Runtime/MathObject.h>
  32. #include <math.h>
  33. namespace JS {
  34. MathObject::MathObject(GlobalObject& global_object)
  35. : Object(*global_object.object_prototype())
  36. {
  37. }
  38. void MathObject::initialize(Interpreter& interpreter, GlobalObject& global_object)
  39. {
  40. Object::initialize(interpreter, global_object);
  41. u8 attr = Attribute::Writable | Attribute::Configurable;
  42. define_native_function("abs", abs, 1, attr);
  43. define_native_function("random", random, 0, attr);
  44. define_native_function("sqrt", sqrt, 1, attr);
  45. define_native_function("floor", floor, 1, attr);
  46. define_native_function("ceil", ceil, 1, attr);
  47. define_native_function("round", round, 1, attr);
  48. define_native_function("max", max, 2, attr);
  49. define_native_function("min", min, 2, attr);
  50. define_native_function("trunc", trunc, 1, attr);
  51. define_native_function("sin", sin, 1, attr);
  52. define_native_function("cos", cos, 1, attr);
  53. define_native_function("tan", tan, 1, attr);
  54. define_native_function("pow", pow, 2, attr);
  55. define_native_function("exp", exp, 1, attr);
  56. define_native_function("expm1", expm1, 1, attr);
  57. define_native_function("sign", sign, 1, attr);
  58. define_native_function("clz32", clz32, 1, attr);
  59. define_native_function("acosh", acosh, 1, attr);
  60. define_native_function("asinh", asinh, 1, attr);
  61. define_native_function("atanh", atanh, 1, attr);
  62. define_native_function("log1p", log1p, 1, attr);
  63. define_native_function("cbrt", cbrt, 1, attr);
  64. define_property("E", Value(M_E), 0);
  65. define_property("LN2", Value(M_LN2), 0);
  66. define_property("LN10", Value(M_LN10), 0);
  67. define_property("LOG2E", Value(log2(M_E)), 0);
  68. define_property("LOG10E", Value(log10(M_E)), 0);
  69. define_property("PI", Value(M_PI), 0);
  70. define_property("SQRT1_2", Value(M_SQRT1_2), 0);
  71. define_property("SQRT2", Value(M_SQRT2), 0);
  72. define_property(interpreter.well_known_symbol_to_string_tag(), js_string(interpreter, "Math"), Attribute::Configurable);
  73. }
  74. MathObject::~MathObject()
  75. {
  76. }
  77. JS_DEFINE_NATIVE_FUNCTION(MathObject::abs)
  78. {
  79. auto number = interpreter.argument(0).to_number(interpreter);
  80. if (interpreter.exception())
  81. return {};
  82. if (number.is_nan())
  83. return js_nan();
  84. return Value(number.as_double() >= 0 ? number.as_double() : -number.as_double());
  85. }
  86. Value MathObject::random(Interpreter&, GlobalObject&)
  87. {
  88. #ifdef __serenity__
  89. double r = (double)arc4random() / (double)UINT32_MAX;
  90. #else
  91. double r = (double)rand() / (double)RAND_MAX;
  92. #endif
  93. return Value(r);
  94. }
  95. JS_DEFINE_NATIVE_FUNCTION(MathObject::sqrt)
  96. {
  97. auto number = interpreter.argument(0).to_number(interpreter);
  98. if (interpreter.exception())
  99. return {};
  100. if (number.is_nan())
  101. return js_nan();
  102. return Value(::sqrt(number.as_double()));
  103. }
  104. JS_DEFINE_NATIVE_FUNCTION(MathObject::floor)
  105. {
  106. auto number = interpreter.argument(0).to_number(interpreter);
  107. if (interpreter.exception())
  108. return {};
  109. if (number.is_nan())
  110. return js_nan();
  111. return Value(::floor(number.as_double()));
  112. }
  113. JS_DEFINE_NATIVE_FUNCTION(MathObject::ceil)
  114. {
  115. auto number = interpreter.argument(0).to_number(interpreter);
  116. if (interpreter.exception())
  117. return {};
  118. if (number.is_nan())
  119. return js_nan();
  120. return Value(::ceil(number.as_double()));
  121. }
  122. JS_DEFINE_NATIVE_FUNCTION(MathObject::round)
  123. {
  124. auto number = interpreter.argument(0).to_number(interpreter);
  125. if (interpreter.exception())
  126. return {};
  127. if (number.is_nan())
  128. return js_nan();
  129. return Value(::round(number.as_double()));
  130. }
  131. JS_DEFINE_NATIVE_FUNCTION(MathObject::max)
  132. {
  133. if (!interpreter.argument_count())
  134. return js_negative_infinity();
  135. auto max = interpreter.argument(0).to_number(interpreter);
  136. if (interpreter.exception())
  137. return {};
  138. for (size_t i = 1; i < interpreter.argument_count(); ++i) {
  139. auto cur = interpreter.argument(i).to_number(interpreter);
  140. if (interpreter.exception())
  141. return {};
  142. max = Value(cur.as_double() > max.as_double() ? cur : max);
  143. }
  144. return max;
  145. }
  146. JS_DEFINE_NATIVE_FUNCTION(MathObject::min)
  147. {
  148. if (!interpreter.argument_count())
  149. return js_infinity();
  150. auto min = interpreter.argument(0).to_number(interpreter);
  151. if (interpreter.exception())
  152. return {};
  153. for (size_t i = 1; i < interpreter.argument_count(); ++i) {
  154. auto cur = interpreter.argument(i).to_number(interpreter);
  155. if (interpreter.exception())
  156. return {};
  157. min = Value(cur.as_double() < min.as_double() ? cur : min);
  158. }
  159. return min;
  160. }
  161. JS_DEFINE_NATIVE_FUNCTION(MathObject::trunc)
  162. {
  163. auto number = interpreter.argument(0).to_number(interpreter);
  164. if (interpreter.exception())
  165. return {};
  166. if (number.is_nan())
  167. return js_nan();
  168. if (number.as_double() < 0)
  169. return MathObject::ceil(interpreter, global_object);
  170. return MathObject::floor(interpreter, global_object);
  171. }
  172. JS_DEFINE_NATIVE_FUNCTION(MathObject::sin)
  173. {
  174. auto number = interpreter.argument(0).to_number(interpreter);
  175. if (interpreter.exception())
  176. return {};
  177. if (number.is_nan())
  178. return js_nan();
  179. return Value(::sin(number.as_double()));
  180. }
  181. JS_DEFINE_NATIVE_FUNCTION(MathObject::cos)
  182. {
  183. auto number = interpreter.argument(0).to_number(interpreter);
  184. if (interpreter.exception())
  185. return {};
  186. if (number.is_nan())
  187. return js_nan();
  188. return Value(::cos(number.as_double()));
  189. }
  190. JS_DEFINE_NATIVE_FUNCTION(MathObject::tan)
  191. {
  192. auto number = interpreter.argument(0).to_number(interpreter);
  193. if (interpreter.exception())
  194. return {};
  195. if (number.is_nan())
  196. return js_nan();
  197. return Value(::tan(number.as_double()));
  198. }
  199. JS_DEFINE_NATIVE_FUNCTION(MathObject::pow)
  200. {
  201. return JS::exp(interpreter, interpreter.argument(0), interpreter.argument(1));
  202. }
  203. JS_DEFINE_NATIVE_FUNCTION(MathObject::exp)
  204. {
  205. auto number = interpreter.argument(0).to_number(interpreter);
  206. if (interpreter.exception())
  207. return {};
  208. if (number.is_nan())
  209. return js_nan();
  210. return Value(::exp(number.as_double()));
  211. }
  212. JS_DEFINE_NATIVE_FUNCTION(MathObject::expm1)
  213. {
  214. auto number = interpreter.argument(0).to_number(interpreter);
  215. if (interpreter.exception())
  216. return {};
  217. if (number.is_nan())
  218. return js_nan();
  219. return Value(::expm1(number.as_double()));
  220. }
  221. JS_DEFINE_NATIVE_FUNCTION(MathObject::sign)
  222. {
  223. auto number = interpreter.argument(0).to_number(interpreter);
  224. if (interpreter.exception())
  225. return {};
  226. if (number.is_positive_zero())
  227. return Value(0);
  228. if (number.is_negative_zero())
  229. return Value(-0.0);
  230. if (number.as_double() > 0)
  231. return Value(1);
  232. if (number.as_double() < 0)
  233. return Value(-1);
  234. return js_nan();
  235. }
  236. JS_DEFINE_NATIVE_FUNCTION(MathObject::clz32)
  237. {
  238. auto number = interpreter.argument(0).to_number(interpreter);
  239. if (interpreter.exception())
  240. return {};
  241. if (!number.is_finite_number() || (unsigned)number.as_double() == 0)
  242. return Value(32);
  243. return Value(__builtin_clz((unsigned)number.as_double()));
  244. }
  245. JS_DEFINE_NATIVE_FUNCTION(MathObject::acosh)
  246. {
  247. auto number = interpreter.argument(0).to_number(interpreter);
  248. if (interpreter.exception())
  249. return {};
  250. if (number.as_double() < 1)
  251. return JS::js_nan();
  252. return Value(::acosh(number.as_double()));
  253. }
  254. JS_DEFINE_NATIVE_FUNCTION(MathObject::asinh)
  255. {
  256. auto number = interpreter.argument(0).to_number(interpreter);
  257. if (interpreter.exception())
  258. return {};
  259. return Value(::asinh(number.as_double()));
  260. }
  261. JS_DEFINE_NATIVE_FUNCTION(MathObject::atanh)
  262. {
  263. auto number = interpreter.argument(0).to_number(interpreter);
  264. if (interpreter.exception())
  265. return {};
  266. if (number.as_double() > 1 || number.as_double() < -1)
  267. return JS::js_nan();
  268. return Value(::atanh(number.as_double()));
  269. }
  270. JS_DEFINE_NATIVE_FUNCTION(MathObject::log1p)
  271. {
  272. auto number = interpreter.argument(0).to_number(interpreter);
  273. if (interpreter.exception())
  274. return {};
  275. if (number.as_double() < -1)
  276. return JS::js_nan();
  277. return Value(::log1p(number.as_double()));
  278. }
  279. JS_DEFINE_NATIVE_FUNCTION(MathObject::cbrt)
  280. {
  281. auto number = interpreter.argument(0).to_number(interpreter);
  282. if (interpreter.exception())
  283. return {};
  284. return Value(::cbrt(number.as_double()));
  285. }
  286. }