gmp 0.4.3-x86-mingw32 → 0.4.7-x86-mingw32

data/CHANGELOG

@@ -1,3 +1,18 @@
+0.4.7:
+  * Added 6 MPFR trig methods, plus eint, li2, gamma, lngamma, zeta, erf, erfc,
+    j0, j1, jn, y0, y1, and yn.
+  * Completely fixed the rounding constants. They are now objects, sporting name,
+    mode, and ieee754 reader methods.
+  * Added 4 MPFR "constants". Their values can change based on precision and
+    rounding mode. const_log2, const_pi, const_euler, const_catalan.
+  * Added GMP::Z.eql? and GMP::Z.hash to allow GMP::Z objects to be proper keys
+    in a hash
+  * "Completed" documentation of GMP::Z.
+  * Started documentation of GMP::Q.
+  * Tests now for GMP::Q.to_s.
+  * Unit test results: 84 tests, 1378 assertions, 0 failures, 0 errors
+  * Unit test results: 74 tests, 719 assertions, 0 failures, 0 errors (w/o MPFR)
+
 0.4.3:
   * Support for MPFR on Windows introduced. gmp-x86-mswin32 gem should be used.
   * Removed compilation warnings when using MPFR
@@ -6,7 +21,7 @@
   * Added MPFR rounding constants. These will be changed soon though.
   * Added MPFR tests adapted straight from the MPFR library, just tsqrt so far.
   * Added 3x MPFR functions: sec(), csc(), cot().
-  * Added function existence tests from
+  * Added function existence tests
   * Unit test results: 78 tests, 1025 assertions, 0 failures, 0 errors
   * Unit test results: 72 tests, 593 assertions, 0 failures, 0 errors  (w/o MPFR)
 

data/README.rdoc

@@ -161,6 +161,7 @@ You can also call them as:
     scan0,scan1              starting at bitnr (1st arg), scan for a 0 or 1
                              (respectively), then return the index of the
                              first instance.
+    cmpabs                   comparison of absolute value
     com                      2's complement
     com!                     in-place 2's complement
     &,|,^                    logical operations: and, or, xor
@@ -230,10 +231,25 @@ You can also call them as:
     log2                     binary logarithm of object
     log10                    decimal logarithm of object
     exp                      e^object
+    exp2                     2^object
+    exp10                    10^object
     log1p                    the same as (object + 1).log, with better
                              precision
     expm1                    the same as (object.exp) - 1, with better
                              precision
+    eint                     exponential integral of object
+    li2                      real part of the dilogarithm of object
+    gamma                    Gamma fucntion of object
+    lngamma                  logarithm of the Gamma function of object
+    zeta                     Reimann Zeta function of object
+    erf                      error function of object
+    erfc                     complementary error function of object
+    j0                       first kind Bessel function of order 0 of object
+    j1                       first kind Bessel function of order 1 of object
+    jn                       first kind Bessel function of order n of object
+    y0                       second kind Bessel function of order 0 of object
+    y1                       second kind Bessel function of order 1 of object
+    yn                       second kind Bessel function of order n of object
     cos                      \
     sin                      |
     tan                      |
@@ -246,6 +262,9 @@ You can also call them as:
     cosh                     | of the object
     sinh                     |
     tanh                     |
+    sec                      |
+    csc                      |
+    cot                      |
     aconh                    |
     asinh                    |
     atanh                    /
@@ -374,7 +393,7 @@ still relevant.
 * better bignum parser
 * zero-copy method for strings generation
 * put rb_raise into nice macros
-* benchmarks against Python GMP (gmpy? Is this still active?) and Perl GMP
+* benchmarks against Python GMP and Perl GMP
 * dup methods
 * integrate F into system
 * should Z.[] bits be 0/1 or true/false, 0 is true, what might badly surprise users

data/ext/gmp.c

@@ -7,6 +7,9 @@
 #include <ruby_gmp.h>
 
 VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
+#ifdef MPFR
+VALUE cGMP_Rnd;
+#endif
 
 void r_gmpz_free(void *ptr)         { mpz_clear (ptr);     free (ptr); }
 void r_gmpq_free(void *ptr)         { mpq_clear (ptr);     free (ptr); }
@@ -55,37 +58,6 @@ static VALUE r_gmpq_initialize(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
-/* don't pass GMP::F here, it should be handled separately */
-void mpf_set_value(MP_FLOAT *self_val, VALUE arg)
-{
-  MP_RAT *arg_val_q;
-  MP_INT *arg_val_z;
-
-  if (GMPQ_P(arg)) {
-    mpq_get_struct(arg, arg_val_q);
-    mpf_set_q(self_val, arg_val_q);
-  } else if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val_z);
-    mpf_set_z(self_val, arg_val_z);
-  } else if (FLOAT_P(arg)) {
-    mpf_set_d(self_val, NUM2DBL(arg));
-  } else if (FIXNUM_P(arg)) {
-    mpf_set_si(self_val, FIX2INT(arg));
-  } else if (STRING_P(arg)) {
-    if (mpf_set_str(self_val, STR2CSTR(arg), 10) == -1) {
-      rb_raise(rb_eRuntimeError, "Badly formatted string");
-    }
-  } else if (BIGNUM_P(arg)) {
-#if 1 /* GMP3 code */
-    mpz_temp_from_bignum(arg_val_z, arg);
-    mpf_set_z(self_val, arg_val_z);
-    mpz_temp_free(arg_val_z);
-#endif
-  } else {
-    rb_raise(rb_eTypeError, "Don't know how to convert %s into GMP::F", rb_class2name(rb_class_of(arg)));
-  }
-}
-
 static VALUE r_gmpz_coerce(VALUE self, VALUE arg)
 {
   return rb_assoc_new(r_gmpzsg_new(1, &arg, cGMP_Z), self);
@@ -126,28 +98,29 @@ static VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
 {
   (void)klass;
   const char *rounding_string_val;
-  VALUE rounding_string;
-  ID method_to_sym = rb_intern("to_sym");
   rounding_string_val = mpfr_print_rnd_mode (mpfr_get_default_rounding_mode ());
-  rounding_string = rb_str_new2 (rounding_string_val);
-  /*return rb_const_get (mGMP, rb_intern (rounding_string));*/
-  return rb_funcall (rounding_string, method_to_sym, 0);
+  if ( rounding_string_val == NULL ) {
+    return Qnil;
+  }
+  else {
+    return rb_const_get (mGMP, rb_intern (rounding_string_val));
+  }
 }
 
 static VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
 {
   (void)klass;
-  int arg_val;
-  if (FIXNUM_P(arg)) {
-    arg_val = FIX2INT(arg);
-    if (arg_val < 0 || arg_val > 3) {
+  VALUE mode;
+  if (GMPRND_P(arg)) {
+    mode = rb_funcall (arg, rb_intern("mode"), 0);
+    if (FIX2INT(mode) < 0 || FIX2INT(mode) > 3) {
       rb_raise(rb_eRangeError, "rounding mode must be one of the rounding mode constants.");
     }
   } else {
     rb_raise(rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
   }
   
-  switch (arg_val) {
+  switch (FIX2INT(mode)) {
     case 0:
       mpfr_set_default_rounding_mode (GMP_RNDN);
       break;
@@ -163,7 +136,35 @@ static VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
   }
   
   return Qnil;
-}  
+}
+
+mp_rnd_t r_get_rounding_mode(VALUE rnd)
+{
+  VALUE mode;
+  
+  if (GMPRND_P(rnd)) {
+    mode = rb_funcall (rnd, rb_intern("mode"), 0);
+    if (FIX2INT(mode) < 0 || FIX2INT(mode) > 3) {
+      rb_raise(rb_eRangeError, "rounding mode must be one of the rounding mode constants.");
+    }
+  } else {
+    rb_raise(rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
+  }
+  
+  switch (FIX2INT(mode)) {
+    case 0:
+      return GMP_RNDN;
+    case 1:
+      return GMP_RNDZ;
+    case 2:
+      return GMP_RNDU;
+    case 3:
+      return GMP_RNDD;
+    default:
+      return GMP_RNDN;
+  }
+}
+
 #endif /* MPFR */
 
 #include "gmpf.h"
@@ -187,39 +188,41 @@ void Init_gmp() {
   rb_define_const(mGMP, "MPFR_VERSION", rb_str_new2(MPFR_VERSION_STRING));
   rb_define_const(mGMP, "MPFR_PREC_MIN", INT2FIX(MPFR_PREC_MIN));
   rb_define_const(mGMP, "MPFR_PREC_MAX", INT2FIX(MPFR_PREC_MAX));
-  rb_define_const(mGMP, "GMP_RNDN", INT2FIX(0));
-  rb_define_const(mGMP, "GMP_RNDZ", INT2FIX(1));
-  rb_define_const(mGMP, "GMP_RNDU", INT2FIX(2));
-  rb_define_const(mGMP, "GMP_RNDD", INT2FIX(3));
+  // rb_define_const(mGMP, "GMP_RNDN", INT2FIX(0));
+  // rb_define_const(mGMP, "GMP_RNDZ", INT2FIX(1));
+  // rb_define_const(mGMP, "GMP_RNDU", INT2FIX(2));
+  // rb_define_const(mGMP, "GMP_RNDD", INT2FIX(3));
 #endif /* MPFR */
 
   cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
-  init_gmpz();
+  init_gmpz ();
   rb_define_method(cGMP_Z, "coerce", r_gmpz_coerce, 1);
 
   cGMP_Q = rb_define_class_under (mGMP, "Q", rb_cNumeric);
-  init_gmpq();
+  init_gmpq ();
   rb_define_method(cGMP_Q, "initialize", r_gmpq_initialize, -1);
   rb_define_method(cGMP_Q, "coerce", r_gmpq_coerce, 1);
   rb_define_method(cGMP_Q, "num", r_gmpq_num, 0);
   rb_define_method(cGMP_Q, "den", r_gmpq_den, 0);
 
   cGMP_F = rb_define_class_under (mGMP, "F", rb_cNumeric);
-  init_gmpf();
+  init_gmpf ();
   rb_define_singleton_method (cGMP_F, "default_prec", r_gmpfsg_get_default_prec, 0);
   rb_define_singleton_method (cGMP_F, "default_prec=", r_gmpfsg_set_default_prec, 1);
 #ifdef MPFR
+  cGMP_Rnd = rb_define_class_under (mGMP, "Rnd", rb_cObject);
   rb_define_singleton_method (cGMP_F, "default_rounding_mode", r_gmpfsg_get_default_rounding_mode, 0);
   rb_define_singleton_method (cGMP_F, "default_rounding_mode=", r_gmpfsg_set_default_rounding_mode, 1);
+  init_gmprnd ();
 #endif /* MPFR */
-  rb_define_method(cGMP_F, "coerce", r_gmpf_coerce, 1); // new method - testing
+  rb_define_method (cGMP_F, "coerce", r_gmpf_coerce, 1); // new method - testing
 
 /*  rb_define_method(cGMP_F, "cmpabs",  r_gmpf_cmpabs, 1);*/
   
   cGMP_RandState = rb_define_class_under (mGMP, "RandState", rb_cObject);
-  init_gmprandstate();
+  init_gmprandstate ();
   
-  init_gmpbench_timing();
+  init_gmpbench_timing ();
 
   // more
 

data/ext/gmpf.c

@@ -70,7 +70,6 @@ VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass)
 {
   MP_FLOAT *res_val;
   VALUE res;
-
   (void)klass;
 
   if (argc > 2)
@@ -126,6 +125,37 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+/* don't pass GMP::F here, it should be handled separately */
+void mpf_set_value(MP_FLOAT *self_val, VALUE arg)
+{
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg, arg_val_q);
+    mpf_set_q(self_val, arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg, arg_val_z);
+    mpf_set_z(self_val, arg_val_z);
+  } else if (FLOAT_P(arg)) {
+    mpf_set_d(self_val, NUM2DBL(arg));
+  } else if (FIXNUM_P(arg)) {
+    mpf_set_si(self_val, FIX2INT(arg));
+  } else if (STRING_P(arg)) {
+    if (mpf_set_str(self_val, STR2CSTR(arg), 10) == -1) {
+      rb_raise(rb_eRuntimeError, "Badly formatted string");
+    }
+  } else if (BIGNUM_P(arg)) {
+#if 1 /* GMP3 code */
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpf_set_z(self_val, arg_val_z);
+    mpz_temp_free(arg_val_z);
+#endif
+  } else {
+    rb_raise(rb_eTypeError, "Don't know how to convert %s into GMP::F", rb_class2name(rb_class_of(arg)));
+  }
+}
+
 /*
  * call-seq:
  *   GMP::F(arg)
@@ -518,19 +548,48 @@ DEFUN_FLOAT_CMP(ge,>=)
 #ifdef MPFR
 
 #define MPFR_SINGLE_FUNCTION(name)                                 \
-VALUE r_gmpfr_##name(VALUE self)                                   \
+VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)            \
 {                                                                  \
   MP_FLOAT *self_val, *res_val;                                    \
-  unsigned long prec;                                              \
+  VALUE rnd_mode, res_prec;                                        \
+  unsigned long prec, res_prec_value;                              \
+  mp_rnd_t rnd_mode_value;                                         \
   VALUE res;                                                       \
                                                                    \
+  rb_scan_args (argc, argv, "02", &rnd_mode, &res_prec);           \
+                                                                   \
   mpf_get_struct_prec (self, self_val, prec);                      \
-  mpf_make_struct_init (res, res_val, prec);                       \
+  if (NIL_P (rnd_mode)) { rnd_mode_value = __gmp_default_rounding_mode; }    \
+  else { rnd_mode_value = r_get_rounding_mode(rnd_mode); }         \
+  if (NIL_P (res_prec)) { res_prec_value = prec; }                 \
+  else { res_prec_value = FIX2INT (res_prec); }                    \
+  mpf_make_struct_init (res, res_val, res_prec_value);             \
   mpfr_##name (res_val, self_val, __gmp_default_rounding_mode);    \
                                                                    \
   return res;                                                      \
 }
 
+#define MPFR_SINGLE_1ARG_FUNCTION(name)                            \
+VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)            \
+{                                                                  \
+  MP_FLOAT *self_val, *res_val;                                    \
+  VALUE arg1, res_prec;                                            \
+  unsigned long prec, arg1_val, res_prec_value;                    \
+  VALUE res;                                                       \
+                                                                   \
+  rb_scan_args (argc, argv, "11", &arg1, &res_prec);               \
+                                                                   \
+  mpf_get_struct_prec (self, self_val, prec);                      \
+  if (!FIXNUM_P (arg1)) { typeerror(ZXB); }                        \
+  arg1_val = FIX2LONG (arg1);                                      \
+  if (NIL_P (res_prec)) { res_prec_value = prec; }                 \
+  else { res_prec_value = FIX2INT (res_prec); }                    \
+  mpf_make_struct_init (res, res_val, res_prec_value);             \
+  mpfr_##name (res_val, arg1_val, self_val, __gmp_default_rounding_mode);    \
+                                                                   \
+  return res;                                                      \
+}
+
 #define MPFR_CONST_FUNCTION(name)                        \
 VALUE r_gmpfrsg_##name()                                 \
 {                                                        \
@@ -550,7 +609,8 @@ MPFR_SINGLE_FUNCTION(log)
 MPFR_SINGLE_FUNCTION(log2)
 MPFR_SINGLE_FUNCTION(log10)
 MPFR_SINGLE_FUNCTION(exp)
-
+MPFR_SINGLE_FUNCTION(exp2)
+MPFR_SINGLE_FUNCTION(exp10)
 MPFR_SINGLE_FUNCTION(cos)
 MPFR_SINGLE_FUNCTION(sin)
 MPFR_SINGLE_FUNCTION(tan)
@@ -566,12 +626,29 @@ MPFR_SINGLE_FUNCTION(cosh)
 MPFR_SINGLE_FUNCTION(sinh)
 MPFR_SINGLE_FUNCTION(tanh)
 
+MPFR_SINGLE_FUNCTION(sech)
+MPFR_SINGLE_FUNCTION(csch)
+MPFR_SINGLE_FUNCTION(coth)
 MPFR_SINGLE_FUNCTION(acosh)
 MPFR_SINGLE_FUNCTION(asinh)
 MPFR_SINGLE_FUNCTION(atanh)
 
 MPFR_SINGLE_FUNCTION(log1p)
 MPFR_SINGLE_FUNCTION(expm1)
+MPFR_SINGLE_FUNCTION(eint)
+MPFR_SINGLE_FUNCTION(li2)
+MPFR_SINGLE_FUNCTION(gamma)
+MPFR_SINGLE_FUNCTION(lngamma)
+/*MPFR_SINGLE_FUNCTION(lgamma)*/
+MPFR_SINGLE_FUNCTION(zeta)
+MPFR_SINGLE_FUNCTION(erf)
+MPFR_SINGLE_FUNCTION(erfc)
+MPFR_SINGLE_FUNCTION(j0)
+MPFR_SINGLE_FUNCTION(j1)
+MPFR_SINGLE_1ARG_FUNCTION(jn)
+MPFR_SINGLE_FUNCTION(y0)
+MPFR_SINGLE_FUNCTION(y1)
+MPFR_SINGLE_1ARG_FUNCTION(yn)
 
 MPFR_CONST_FUNCTION(const_log2)
 MPFR_CONST_FUNCTION(const_pi)
@@ -743,7 +820,7 @@ void init_gmpf()
   
 #ifdef MPFR
   // Basic Arithmetic Functions
-  rb_define_method(cGMP_F, "sqrt", r_gmpfr_sqrt, 0);
+  rb_define_method(cGMP_F, "sqrt", r_gmpfr_sqrt, -1);
   
   rb_define_method(cGMP_F, "**", r_gmpfr_pow, 1);
   
@@ -754,32 +831,50 @@ void init_gmpf()
   rb_define_method(cGMP_F, "number?", r_gmpfr_number_p, 0);
   
   // Special Functions
-  rb_define_method(cGMP_F, "log",   r_gmpfr_log,   0);
-  rb_define_method(cGMP_F, "log2",  r_gmpfr_log2,  0);
-  rb_define_method(cGMP_F, "log10", r_gmpfr_log10, 0);
-  rb_define_method(cGMP_F, "exp",   r_gmpfr_exp,   0);
-  
-  rb_define_method(cGMP_F, "cos",   r_gmpfr_cos,   0);
-  rb_define_method(cGMP_F, "sin",   r_gmpfr_sin,   0);
-  rb_define_method(cGMP_F, "tan",   r_gmpfr_tan,   0);
-  rb_define_method(cGMP_F, "sec",   r_gmpfr_sec,   0);
-  rb_define_method(cGMP_F, "csc",   r_gmpfr_csc,   0);
-  rb_define_method(cGMP_F, "cot",   r_gmpfr_cot,   0);
+  rb_define_method(cGMP_F, "log",   r_gmpfr_log,   -1);
+  rb_define_method(cGMP_F, "log2",  r_gmpfr_log2,  -1);
+  rb_define_method(cGMP_F, "log10", r_gmpfr_log10, -1);
+  rb_define_method(cGMP_F, "exp",   r_gmpfr_exp,   -1);
+  rb_define_method(cGMP_F, "exp2",  r_gmpfr_exp2,  -1);
+  rb_define_method(cGMP_F, "exp10", r_gmpfr_exp10, -1);
+  rb_define_method(cGMP_F, "cos",   r_gmpfr_cos,   -1);
+  rb_define_method(cGMP_F, "sin",   r_gmpfr_sin,   -1);
+  rb_define_method(cGMP_F, "tan",   r_gmpfr_tan,   -1);
+  rb_define_method(cGMP_F, "sec",   r_gmpfr_sec,   -1);
+  rb_define_method(cGMP_F, "csc",   r_gmpfr_csc,   -1);
+  rb_define_method(cGMP_F, "cot",   r_gmpfr_cot,   -1);
   
-  rb_define_method(cGMP_F, "acos",  r_gmpfr_acos,  0);
-  rb_define_method(cGMP_F, "asin",  r_gmpfr_asin,  0);
-  rb_define_method(cGMP_F, "atan",  r_gmpfr_atan,  0);
+  rb_define_method(cGMP_F, "acos",  r_gmpfr_acos,  -1);
+  rb_define_method(cGMP_F, "asin",  r_gmpfr_asin,  -1);
+  rb_define_method(cGMP_F, "atan",  r_gmpfr_atan,  -1);
   
-  rb_define_method(cGMP_F, "cosh",  r_gmpfr_cosh,  0);
-  rb_define_method(cGMP_F, "sinh",  r_gmpfr_sinh,  0);
-  rb_define_method(cGMP_F, "tanh",  r_gmpfr_tanh,  0);
+  rb_define_method(cGMP_F, "cosh",  r_gmpfr_cosh,  -1);
+  rb_define_method(cGMP_F, "sinh",  r_gmpfr_sinh,  -1);
+  rb_define_method(cGMP_F, "tanh",  r_gmpfr_tanh,  -1);
   
-  rb_define_method(cGMP_F, "acosh", r_gmpfr_acosh, 0);
-  rb_define_method(cGMP_F, "asinh", r_gmpfr_asinh, 0);
-  rb_define_method(cGMP_F, "atanh", r_gmpfr_atanh, 0);
+  rb_define_method(cGMP_F, "sech",  r_gmpfr_sech,  -1);
+  rb_define_method(cGMP_F, "csch",  r_gmpfr_csch,  -1);
+  rb_define_method(cGMP_F, "coth",  r_gmpfr_coth,  -1);
+  rb_define_method(cGMP_F, "acosh", r_gmpfr_acosh, -1);
+  rb_define_method(cGMP_F, "asinh", r_gmpfr_asinh, -1);
+  rb_define_method(cGMP_F, "atanh", r_gmpfr_atanh, -1);
   
-  rb_define_method(cGMP_F, "log1p", r_gmpfr_log1p, 0);
-  rb_define_method(cGMP_F, "expm1", r_gmpfr_expm1, 0);
+  rb_define_method(cGMP_F, "log1p",   r_gmpfr_log1p,   -1);
+  rb_define_method(cGMP_F, "expm1",   r_gmpfr_expm1,   -1);
+  rb_define_method(cGMP_F, "eint",    r_gmpfr_eint,    -1);
+  rb_define_method(cGMP_F, "li2",     r_gmpfr_li2,     -1);
+  rb_define_method(cGMP_F, "gamma",   r_gmpfr_gamma,   -1);
+  rb_define_method(cGMP_F, "lngamma", r_gmpfr_lngamma, -1);
+  /*rb_define_method(cGMP_F, "lgamma",  r_gmpfr_lgamma,   -1);*/
+  rb_define_method(cGMP_F, "zeta", r_gmpfr_zeta,       -1);
+  rb_define_method(cGMP_F, "erf", r_gmpfr_erf,         -1);
+  rb_define_method(cGMP_F, "erfc", r_gmpfr_erfc,       -1);
+  rb_define_method(cGMP_F, "j0", r_gmpfr_j0,           -1);
+  rb_define_method(cGMP_F, "j1", r_gmpfr_j1,           -1);
+  rb_define_method(cGMP_F, "jn", r_gmpfr_jn,           -1);
+  rb_define_method(cGMP_F, "y0", r_gmpfr_y0,           -1);
+  rb_define_method(cGMP_F, "y1", r_gmpfr_y1,           -1);
+  rb_define_method(cGMP_F, "yn", r_gmpfr_yn,           -1);
   
   rb_define_singleton_method(cGMP_F, "const_log2",    r_gmpfrsg_const_log2,    0);
   rb_define_singleton_method(cGMP_F, "const_pi",      r_gmpfrsg_const_pi,      0);