Renaming ecma_op_number_{add,subtract,multiply,divide} -> ecma_number_{add,subtract,multiply,divide}.

Moving ecma_number_{add,subtract,multiply,divide} to src/libecmaobjects/ecma-helpers-number.c. Moving abs, sqrt, ln, exp, calculation helpers from src/libecmabuiltins/ecma-builtin-math-object.c to src/libecmaobjects/ecma-helpers-number.c.
2014-10-20 18:46:43 +04:00
parent a8ed76591a
commit 3eed2d0d4c
8 changed files with 282 additions and 305 deletions
@@ -75,6 +75,11 @@ typedef struct
 *          IEEE-754 2008, 3.6, Table 3.5
 */
 const int32_t ecma_number_exponent_bias = 127;
+
+/**
+ * Relative precision used in calculation with ecma-numbers
+ */
+const ecma_number_t ecma_number_relative_eps = 1.0e-10f;
 #elif defined (CONFIG_ECMA_NUMBER_FLOAT64)
 JERRY_STATIC_ASSERT (sizeof (ecma_number_t) == sizeof (uint64_t));

@@ -127,6 +132,11 @@ typedef struct
 *          IEEE-754 2008, 3.6, Table 3.5
 */
 const int32_t ecma_number_exponent_bias = 1023;
+
+/**
+ * Relative precision used in calculation with ecma-numbers
+ */
+const ecma_number_t ecma_number_relative_eps = 1.0e-16;
 #else /* !CONFIG_ECMA_NUMBER_FLOAT32 && !CONFIG_ECMA_NUMBER_FLOAT64 */
 # error "!CONFIG_ECMA_NUMBER_FLOAT32 && !CONFIG_ECMA_NUMBER_FLOAT64"
 #endif /* !CONFIG_ECMA_NUMBER_FLOAT32 && !CONFIG_ECMA_NUMBER_FLOAT64 */
@@ -399,6 +409,227 @@ ecma_number_negate (ecma_number_t num) /**< ecma-number */
  return u.value;
 } /* ecma_number_negate */

+/**
+ * ECMA-number addition.
+ *
+ * @return number - result of addition.
+ */
+ecma_number_t
+ecma_number_add (ecma_number_t left_num, /**< left operand */
+                 ecma_number_t right_num) /**< right operand */
+{
+  return left_num + right_num;
+} /* ecma_number_add */
+
+/**
+ * ECMA-number substraction.
+ *
+ * @return number - result of substraction.
+ */
+ecma_number_t
+ecma_number_substract (ecma_number_t left_num, /**< left operand */
+                       ecma_number_t right_num) /**< right operand */
+{
+  return ecma_number_add (left_num, ecma_number_negate (right_num));
+} /* ecma_number_substract */
+
+/**
+ * ECMA-number multiplication.
+ *
+ * @return number - result of multiplication.
+ */
+ecma_number_t
+ecma_number_multiply (ecma_number_t left_num, /**< left operand */
+                      ecma_number_t right_num) /**< right operand */
+{
+  return left_num * right_num;
+} /* ecma_number_multiply */
+
+/**
+ * ECMA-number division.
+ *
+ * @return number - result of division.
+ */
+ecma_number_t
+ecma_number_divide (ecma_number_t left_num, /**< left operand */
+                    ecma_number_t right_num) /**< right operand */
+{
+  return left_num / right_num;
+} /* ecma_number_divide */
+
+/**
+ * Helper for calculating absolute value
+ *
+ * Warning:
+ *         argument should be valid number
+ *
+ * @return absolute value of the argument
+ */
+ecma_number_t
+ecma_number_abs (ecma_number_t num) /**< valid number */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+
+  if (num < 0)
+  {
+    return ecma_number_negate (num);
+  }
+  else
+  {
+    return num;
+  }
+} /* ecma_number_abs */
+
+/**
+ * Helper for calculating square root using Newton's method.
+ *
+ * @return square root of specified number
+ */
+ecma_number_t
+ecma_number_sqrt (ecma_number_t num) /**< valid finite
+                                          positive number */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+  JERRY_ASSERT (!ecma_number_is_infinity (num));
+  JERRY_ASSERT (!ecma_number_is_negative (num));
+
+  ecma_number_t x = ECMA_NUMBER_ONE;
+  ecma_number_t diff = ecma_number_make_infinity (false);
+
+  while (ecma_number_divide (diff, x) > ecma_number_relative_eps)
+  {
+    ecma_number_t x_next = ecma_number_multiply (ECMA_NUMBER_HALF,
+                                                 (ecma_number_add (x,
+                                                                   ecma_number_divide (num, x))));
+
+    diff = ecma_number_substract (x, x_next);
+    if (diff < 0)
+    {
+      diff = ecma_number_negate (diff);
+    }
+
+    x = x_next;
+  }
+
+  return x;
+} /* ecma_number_sqrt */
+
+/**
+ * Helper for calculating natural logarithm.
+ *
+ * @return natural logarithm of specified number
+ */
+ecma_number_t
+ecma_number_ln (ecma_number_t num) /**< valid finite
+                                        positive number */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+  JERRY_ASSERT (!ecma_number_is_infinity (num));
+  JERRY_ASSERT (!ecma_number_is_negative (num));
+
+  if (num == ECMA_NUMBER_ONE)
+  {
+    return ECMA_NUMBER_ZERO;
+  }
+
+  /* Taylor series of ln (1 + x) around x = 0 is x - x^2/2 + x^3/3 - x^4/4 + ... */
+
+  ecma_number_t x = num;
+  ecma_number_t multiplier = ECMA_NUMBER_ONE;
+
+  while (ecma_number_abs (ecma_number_substract (x,
+                                                 ECMA_NUMBER_ONE)) > ECMA_NUMBER_HALF)
+  {
+    x = ecma_number_sqrt (x);
+    multiplier = ecma_number_multiply (multiplier, ECMA_NUMBER_TWO);
+  }
+
+  x = ecma_number_substract (x, ECMA_NUMBER_ONE);
+
+  ecma_number_t sum = ECMA_NUMBER_ZERO;
+  ecma_number_t next_power = x;
+  ecma_number_t next_divisor = ECMA_NUMBER_ONE;
+
+  ecma_number_t diff;
+
+  do
+  {
+    ecma_number_t next_sum = ecma_number_add (sum,
+                                              ecma_number_divide (next_power,
+                                                                  next_divisor));
+
+    next_divisor = ecma_number_add (next_divisor, ECMA_NUMBER_ONE);
+    next_power = ecma_number_multiply (next_power, x);
+    next_power = ecma_number_negate (next_power);
+
+    diff = ecma_number_abs (ecma_number_substract (sum, next_sum));
+
+    sum = next_sum;
+  }
+  while (ecma_number_abs (ecma_number_divide (diff,
+                                              sum)) > ecma_number_relative_eps);
+
+  sum = ecma_number_multiply (sum, multiplier);
+
+  return sum;
+} /* ecma_number_ln */
+
+/**
+ * Helper for calculating exponent of a number
+ *
+ * @return exponent of specified number
+ */
+ecma_number_t
+ecma_number_exp (ecma_number_t num) /**< valid finite number */
+{
+  JERRY_ASSERT (!ecma_number_is_nan (num));
+  JERRY_ASSERT (!ecma_number_is_infinity (num));
+
+  bool invert = false;
+  ecma_number_t pow_e;
+
+  if (ecma_number_is_negative (num))
+  {
+    invert = true;
+    pow_e = ecma_number_negate (num);
+  }
+  else
+  {
+    pow_e = num;
+  }
+
+  /* Taylor series of e^x is 1 + x/1! + x^2/2! + x^3/3! + ... + x^n/n! + ... */
+
+  ecma_number_t sum = ECMA_NUMBER_ONE;
+  ecma_number_t next_addendum = ecma_number_divide (pow_e, ECMA_NUMBER_ONE);
+  ecma_number_t next_factorial_factor = ECMA_NUMBER_ONE;
+
+  ecma_number_t diff = ecma_number_make_infinity (false);
+
+  while (ecma_number_divide (diff, sum) > ecma_number_relative_eps)
+  {
+    ecma_number_t next_sum = ecma_number_add (sum, next_addendum);
+
+    next_factorial_factor = ecma_number_add (next_factorial_factor, ECMA_NUMBER_ONE);
+    next_addendum = ecma_number_multiply (next_addendum, pow_e);
+    next_addendum = ecma_number_divide (next_addendum, next_factorial_factor);
+
+    diff = ecma_number_substract (sum, next_sum);
+    if (diff < 0)
+    {
+      diff = ecma_number_negate (diff);
+    }
+
+    sum = next_sum;
+  }
+
+  if (invert)
+  {
+    sum = ecma_number_divide (ECMA_NUMBER_ONE, sum);
+  }
+
+  return sum;
+} /* ecma_number_exp */

 /**
 * @}
@@ -129,6 +129,8 @@ extern bool ecma_is_string_magic (ecma_string_t *string_p, ecma_magic_string_id_
 extern bool ecma_is_zt_string_magic (ecma_char_t *zt_string_p, ecma_magic_string_id_t *out_id_p);

 /* ecma-helpers-number.c */
+extern const ecma_number_t ecma_number_relative_eps;
+
 extern ecma_number_t ecma_number_make_nan (void);
 extern ecma_number_t ecma_number_make_infinity (bool sign);
 extern bool ecma_number_is_nan (ecma_number_t num);
@@ -141,6 +143,14 @@ extern int32_t ecma_number_get_fraction_and_exponent (ecma_number_t num,
 extern ecma_number_t ecma_number_make_normal_positive_from_fraction_and_exponent (uint64_t fraction,
                                                                                  int32_t exponent);
 extern ecma_number_t ecma_number_negate (ecma_number_t num);
+extern ecma_number_t ecma_number_add (ecma_number_t left_num, ecma_number_t right_num);
+extern ecma_number_t ecma_number_substract (ecma_number_t left_num, ecma_number_t right_num);
+extern ecma_number_t ecma_number_multiply (ecma_number_t left_num, ecma_number_t right_num);
+extern ecma_number_t ecma_number_divide (ecma_number_t left_num, ecma_number_t right_num);
+extern ecma_number_t ecma_number_sqrt (ecma_number_t num);
+extern ecma_number_t ecma_number_abs (ecma_number_t num);
+extern ecma_number_t ecma_number_ln (ecma_number_t num);
+extern ecma_number_t ecma_number_exp (ecma_number_t num);

 /* ecma-helpers-values-collection.c */