bigdecimal 3.1.7 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8bd666f800ebaf8bf81b991c2220587d621521c6d02548680bfbb4ff55b245b7
-  data.tar.gz: 15be279642ac5dd98f2470df7a46fc288992b450a1d5f1629d52c701377d191d
+  metadata.gz: d4fdad45c0e9519d352fa25d4134af80ce6897c8196bcb3bf0e25d6ebcea8918
+  data.tar.gz: ed56f36c2e5fd8cea29b0de49ac2c25edf186de643d69aff660677ada7a79ae8
 SHA512:
-  metadata.gz: 123b9d9b3b3a5d9ab3664b2887cee0d846f8b9a1e87d590e06751a844759e31e4286b28ad578e6fb14b4975890ed7179cbfbc660196b6cb3c23f9cb8e7eddb16
-  data.tar.gz: 6ad102cec32ddceb2c6c19fdb4821bda9fe9c3c0e07b4b3d3eb8b98ce9b3ec60d887d1446efecce0d86675b02d5138a11028ea1bd2cd494ddc3a836082e9ba7a
+  metadata.gz: 2481253ce262ad322882ca3c3ae5c14eec4b4cc599c34c4aac0e71f3161cece17adce5b506fc94548018ab9605c411e1746d40bdc9f086ef3dfd085197ce7d15
+  data.tar.gz: cb3ee7815dd3d4f63271ffb09c09ff485dd9603b6fc5cb639416cf1f7c20df576aac5e53c891245bbc0a03789b4f2dcd514cf7e48c186f05f58600a799a5ed6e

data/bigdecimal.gemspec

@@ -52,4 +52,6 @@ Gem::Specification.new do |s|
   end
 
   s.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  s.metadata["changelog_uri"] = s.homepage + "/blob/master/CHANGES.md"
 end

data/ext/bigdecimal/bigdecimal.c

@@ -31,7 +31,7 @@
 #include "bits.h"
 #include "static_assert.h"
 
-#define BIGDECIMAL_VERSION "3.1.7"
+#define BIGDECIMAL_VERSION "3.2.0"
 
 /* #define ENABLE_NUMERIC_STRING */
 
@@ -1485,7 +1485,8 @@ BigDecimal_add(VALUE self, VALUE r)
     return VpCheckGetValue(c);
 }
 
- /*  call-seq:
+ /*
+  *  call-seq:
   *    self - value -> bigdecimal
   *
   *  Returns the \BigDecimal difference of +self+ and +value+:
@@ -1780,6 +1781,17 @@ BigDecimal_neg(VALUE self)
     return VpCheckGetValue(c);
 }
 
+/*
+ * call-seq:
+ *   a * b   -> bigdecimal
+ *
+ * Multiply by the specified value.
+ *
+ * The result precision will be the precision of the sum of each precision.
+ *
+ * See BigDecimal#mult.
+ */
+
 static VALUE
 BigDecimal_mult(VALUE self, VALUE r)
 {
@@ -1807,55 +1819,6 @@ BigDecimal_mult(VALUE self, VALUE r)
     return VpCheckGetValue(c);
 }
 
-static VALUE
-BigDecimal_divide(VALUE self, VALUE r, Real **c, Real **res, Real **div)
-/* For c = self.div(r): with round operation */
-{
-    ENTER(5);
-    Real *a, *b;
-    ssize_t a_prec, b_prec;
-    size_t mx;
-
-    TypedData_Get_Struct(self, Real, &BigDecimal_data_type, a);
-    SAVE(a);
-
-    VALUE rr = r;
-    if (is_kind_of_BigDecimal(rr)) {
-        /* do nothing */
-    }
-    else if (RB_INTEGER_TYPE_P(r)) {
-        rr = rb_inum_convert_to_BigDecimal(r, 0, true);
-    }
-    else if (RB_TYPE_P(r, T_FLOAT)) {
-        rr = rb_float_convert_to_BigDecimal(r, 0, true);
-    }
-    else if (RB_TYPE_P(r, T_RATIONAL)) {
-        rr = rb_rational_convert_to_BigDecimal(r, a->Prec*BASE_FIG, true);
-    }
-
-    if (!is_kind_of_BigDecimal(rr)) {
-        return DoSomeOne(self, r, '/');
-    }
-
-    TypedData_Get_Struct(rr, Real, &BigDecimal_data_type, b);
-    SAVE(b);
-    *div = b;
-
-    BigDecimal_count_precision_and_scale(self, &a_prec, NULL);
-    BigDecimal_count_precision_and_scale(rr, &b_prec, NULL);
-    mx = (a_prec > b_prec) ? a_prec : b_prec;
-    mx *= 2;
-
-    if (2*BIGDECIMAL_DOUBLE_FIGURES > mx)
-        mx = 2*BIGDECIMAL_DOUBLE_FIGURES;
-
-    GUARD_OBJ((*c), NewZeroWrapNolimit(1, mx + 2*BASE_FIG));
-    GUARD_OBJ((*res), NewZeroWrapNolimit(1, (mx + 1)*2 + 2*BASE_FIG));
-    VpDivd(*c, *res, a, b);
-
-    return Qnil;
-}
-
 static VALUE BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod);
 
 /* call-seq:
@@ -1873,20 +1836,15 @@ static VALUE
 BigDecimal_div(VALUE self, VALUE r)
 /* For c = self/r: with round operation */
 {
-    ENTER(5);
-    Real *c=NULL, *res=NULL, *div = NULL;
-    r = BigDecimal_divide(self, r, &c, &res, &div);
-    if (!NIL_P(r)) return r; /* coerced by other */
-    SAVE(c); SAVE(res); SAVE(div);
-    /* a/b = c + r/b */
-    /* c xxxxx
-       r 00000yyyyy  ==> (y/b)*BASE >= HALF_BASE
-     */
-    /* Round */
-    if (VpHasVal(div)) { /* frac[0] must be zero for NaN,INF,Zero */
-        VpInternalRound(c, 0, c->frac[c->Prec-1], (DECDIG)(VpBaseVal() * (DECDIG_DBL)res->frac[0] / div->frac[0]));
+    if (
+        !is_kind_of_BigDecimal(r) &&
+        !RB_INTEGER_TYPE_P(r) &&
+        !RB_TYPE_P(r, T_FLOAT) &&
+        !RB_TYPE_P(r, T_RATIONAL)
+    ) {
+        return DoSomeOne(self, r, '/');
     }
-    return VpCheckGetValue(c);
+    return BigDecimal_div2(self, r, INT2FIX(0));
 }
 
 static VALUE BigDecimal_round(int argc, VALUE *argv, VALUE self);
@@ -2042,8 +2000,8 @@ BigDecimal_DoDivmod(VALUE self, VALUE r, Real **div, Real **mod)
 }
 
 /* call-seq:
- * a % b
- * a.modulo(b)
+ *   a % b
+ *   a.modulo(b)
  *
  * Returns the modulus from dividing by b.
  *
@@ -2116,7 +2074,7 @@ BigDecimal_divremain(VALUE self, VALUE r, Real **dv, Real **rv)
 }
 
 /* call-seq:
- * remainder(value)
+ *   remainder(value)
  *
  * Returns the remainder from dividing by the value.
  *
@@ -2133,7 +2091,7 @@ BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
 }
 
 /* call-seq:
- * divmod(value)
+ *   divmod(value)
  *
  * Divides by the specified value, and returns the quotient and modulus
  * as BigDecimal numbers. The quotient is rounded towards negative infinity.
@@ -2176,6 +2134,9 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
 {
     ENTER(5);
     SIGNED_VALUE ix;
+    Real *res = NULL;
+    Real *av = NULL, *bv = NULL, *cv = NULL;
+    size_t mx, pl;
 
     if (NIL_P(n)) { /* div in Float sense */
         Real *div = NULL;
@@ -2188,33 +2149,48 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
 
     /* div in BigDecimal sense */
     ix = check_int_precision(n);
-    if (ix == 0) {
-        return BigDecimal_div(self, b);
-    }
-    else {
-        Real *res = NULL;
-        Real *av = NULL, *bv = NULL, *cv = NULL;
-        size_t mx = ix + VpBaseFig()*2;
-        size_t b_prec = ix;
-        size_t pl = VpSetPrecLimit(0);
-
-        GUARD_OBJ(cv, NewZeroWrapLimited(1, mx + VpBaseFig()));
-        GUARD_OBJ(av, GetVpValue(self, 1));
+
+    pl = VpSetPrecLimit(0);
+
+    GUARD_OBJ(av, GetVpValue(self, 1));
+    if (RB_FLOAT_TYPE_P(b) && ix > BIGDECIMAL_DOUBLE_FIGURES) {
         /* TODO: I want to refactor this precision control for a float value later
          *       by introducing an implicit conversion function instead of
          *       GetVpValueWithPrec.  */
-        if (RB_FLOAT_TYPE_P(b) && b_prec > BIGDECIMAL_DOUBLE_FIGURES) {
-            b_prec = BIGDECIMAL_DOUBLE_FIGURES;
-        }
-        GUARD_OBJ(bv, GetVpValueWithPrec(b, b_prec, 1));
-        mx = av->Prec + bv->Prec + 2;
-        if (mx <= cv->MaxPrec) mx = cv->MaxPrec + 1;
-        GUARD_OBJ(res, NewZeroWrapNolimit(1, (mx * 2  + 2)*VpBaseFig()));
-        VpDivd(cv, res, av, bv);
-        VpSetPrecLimit(pl);
-        VpLeftRound(cv, VpGetRoundMode(), ix);
-        return VpCheckGetValue(cv);
+        GUARD_OBJ(bv, GetVpValueWithPrec(b, BIGDECIMAL_DOUBLE_FIGURES, 1));
     }
+    else {
+        GUARD_OBJ(bv, GetVpValueWithPrec(b, ix, 1));
+    }
+
+    if (ix == 0) {
+        ssize_t a_prec, b_prec;
+        BigDecimal_count_precision_and_scale(av->obj, &a_prec, NULL);
+        BigDecimal_count_precision_and_scale(bv->obj, &b_prec, NULL);
+        ix = ((a_prec > b_prec) ? a_prec : b_prec) + BIGDECIMAL_DOUBLE_FIGURES;
+        if (2 * BIGDECIMAL_DOUBLE_FIGURES > ix)
+            ix = 2 * BIGDECIMAL_DOUBLE_FIGURES;
+    }
+
+    // VpDivd needs 2 extra DECDIGs. One more is needed for rounding.
+    GUARD_OBJ(cv, NewZeroWrapLimited(1, ix + 3 * VpBaseFig()));
+
+    mx = bv->Prec + cv->MaxPrec - 1;
+    if (mx <= av->Prec) mx = av->Prec + 1;
+    GUARD_OBJ(res, NewZeroWrapNolimit(1, mx * VpBaseFig()));
+    VpDivd(cv, res, av, bv);
+    VpSetPrecLimit(pl);
+    if (!VpIsZero(res)) {
+        // Remainder value affects rounding result.
+        // ROUND_UP cv = 0.1e0 with ix=10 will be:
+        // 0.1e0 if remainder == 0
+        // 0.1000000001e0 if remainder != 0
+        size_t idx = roomof(ix, BASE_FIG);
+        while (cv->Prec <= idx) cv->frac[cv->Prec++] = 0;
+        if (cv->frac[idx] == 0 || cv->frac[idx] == HALF_BASE) cv->frac[idx]++;
+    }
+    VpLeftRound(cv, VpGetRoundMode(), ix);
+    return VpCheckGetValue(cv);
 }
 
  /*
@@ -2305,7 +2281,7 @@ BigDecimal_add2(VALUE self, VALUE b, VALUE n)
 }
 
 /* call-seq:
- * sub(value, digits)  -> bigdecimal
+ *   sub(value, digits)  -> bigdecimal
  *
  * Subtract the specified value.
  *
@@ -2404,7 +2380,7 @@ BigDecimal_abs(VALUE self)
 }
 
 /* call-seq:
- * sqrt(n)
+ *   sqrt(n)
  *
  * Returns the square root of the value.
  *
@@ -2445,10 +2421,10 @@ BigDecimal_fix(VALUE self)
 }
 
 /* call-seq:
- * round(n, mode)
+ *   round(n, mode)
  *
  * Round to the nearest integer (by default), returning the result as a
- * BigDecimal if n is specified, or as an Integer if it isn't.
+ * BigDecimal if n is specified and positive, or as an Integer if it isn't.
  *
  *	BigDecimal('3.14159').round #=> 3
  *	BigDecimal('8.7').round #=> 9
@@ -2456,6 +2432,7 @@ BigDecimal_fix(VALUE self)
  *
  *	BigDecimal('3.14159').round(2).class.name #=> "BigDecimal"
  *	BigDecimal('3.14159').round.class.name #=> "Integer"
+ *	BigDecimal('3.14159').round(0).class.name #=> "Integer"
  *
  * If n is specified and positive, the fractional part of the result has no
  * more than that many digits.
@@ -2522,7 +2499,7 @@ BigDecimal_round(int argc, VALUE *argv, VALUE self)
 }
 
 /* call-seq:
- * truncate(n)
+ *   truncate(n)
  *
  * Truncate to the nearest integer (by default), returning the result as a
  * BigDecimal.
@@ -2584,7 +2561,7 @@ BigDecimal_frac(VALUE self)
 }
 
 /* call-seq:
- * floor(n)
+ *   floor(n)
  *
  * Return the largest integer less than or equal to the value, as a BigDecimal.
  *
@@ -2631,7 +2608,7 @@ BigDecimal_floor(int argc, VALUE *argv, VALUE self)
 }
 
 /* call-seq:
- * ceil(n)
+ *   ceil(n)
  *
  * Return the smallest integer greater than or equal to the value, as a BigDecimal.
  *
@@ -2674,7 +2651,7 @@ BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
 }
 
 /* call-seq:
- * to_s(s)
+ *   to_s(s)
  *
  * Converts the value to a string.
  *
@@ -2984,8 +2961,8 @@ bigdecimal_power_by_bigdecimal(Real const* x, Real const* exp, ssize_t const n)
 }
 
 /* call-seq:
- * power(n)
- * power(n, prec)
+ *   power(n)
+ *   power(n, prec)
  *
  * Returns the value raised to the power of n.
  *
@@ -3257,10 +3234,11 @@ BigDecimal_initialize_copy(VALUE self, VALUE other)
     return self;
 }
 
+/* :nodoc: */
 static VALUE
 BigDecimal_clone(VALUE self)
 {
-  return self;
+    return self;
 }
 
 #ifdef HAVE_RB_OPTS_EXCEPTION_P
@@ -3758,6 +3736,12 @@ f_BigDecimal(int argc, VALUE *argv, VALUE self)
     return rb_convert_to_BigDecimal(val, digs, exception);
 }
 
+/*  call-seq:
+ *    BigDecimal.interpret_loosely(string) -> bigdecimal
+ *
+ *  Returns the +BigDecimal+ converted loosely from +string+.
+ */
+
 static VALUE
 BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
 {
@@ -3769,8 +3753,9 @@ BigDecimal_s_interpret_loosely(VALUE klass, VALUE str)
         return VpCheckGetValue(vp);
 }
 
- /* call-seq:
-  * BigDecimal.limit(digits)
+ /*
+  * call-seq:
+  *   BigDecimal.limit(digits)
   *
   * Limit the number of significant digits in newly created BigDecimal
   * numbers to the specified value. Rounding is performed as necessary,
@@ -3904,7 +3889,7 @@ BigDecimal_save_limit(VALUE self)
 }
 
 /* call-seq:
- * BigMath.exp(decimal, numeric)    -> BigDecimal
+ *   BigMath.exp(decimal, numeric)    -> BigDecimal
  *
  * Computes the value of e (the base of natural logarithms) raised to the
  * power of +decimal+, to the specified number of digits of precision.
@@ -4035,7 +4020,7 @@ BigMath_s_exp(VALUE klass, VALUE x, VALUE vprec)
 }
 
 /* call-seq:
- * BigMath.log(decimal, numeric)    -> BigDecimal
+ *   BigMath.log(decimal, numeric)    -> BigDecimal
  *
  * Computes the natural logarithm of +decimal+ to the specified number of
  * digits of precision, +numeric+.
@@ -4238,6 +4223,17 @@ BigDecimal_negative_zero(void)
     return BIGDECIMAL_NEGATIVE_ZERO;
 }
 
+static inline VALUE
+BigDecimal_literal(const char *str)
+{
+    VALUE arg = rb_str_new_cstr(str);
+    VALUE val = f_BigDecimal(1, &arg, rb_cBigDecimal);
+    rb_gc_register_mark_object(val);
+    return val;
+}
+
+#define BIGDECIMAL_LITERAL(var, val) (BIGDECIMAL_ ## var = BigDecimal_literal(#val))
+
 /* Document-class: BigDecimal
  * BigDecimal provides arbitrary-precision floating point decimal arithmetic.
  *
@@ -4394,7 +4390,6 @@ Init_bigdecimal(void)
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
     rb_ext_ractor_safe(true);
 #endif
-    VALUE arg;
 
     id_BigDecimal_exception_mode = rb_intern_const("BigDecimal.exception_mode");
     id_BigDecimal_rounding_mode = rb_intern_const("BigDecimal.rounding_mode");
@@ -4532,33 +4527,19 @@ Init_bigdecimal(void)
     rb_define_const(rb_cBigDecimal, "SIGN_NEGATIVE_INFINITE", INT2FIX(VP_SIGN_NEGATIVE_INFINITE));
 
     /* Positive zero value. */
-    arg = rb_str_new2("+0");
-    BIGDECIMAL_POSITIVE_ZERO = f_BigDecimal(1, &arg, rb_cBigDecimal);
-    rb_gc_register_mark_object(BIGDECIMAL_POSITIVE_ZERO);
+    BIGDECIMAL_LITERAL(POSITIVE_ZERO, +0);
 
     /* Negative zero value. */
-    arg = rb_str_new2("-0");
-    BIGDECIMAL_NEGATIVE_ZERO = f_BigDecimal(1, &arg, rb_cBigDecimal);
-    rb_gc_register_mark_object(BIGDECIMAL_NEGATIVE_ZERO);
+    BIGDECIMAL_LITERAL(NEGATIVE_ZERO, -0);
 
-    /* Positive infinity value. */
-    arg = rb_str_new2("+Infinity");
-    BIGDECIMAL_POSITIVE_INFINITY = f_BigDecimal(1, &arg, rb_cBigDecimal);
-    rb_gc_register_mark_object(BIGDECIMAL_POSITIVE_INFINITY);
+    /* Positive infinity[rdoc-ref:BigDecimal@Infinity] value. */
+    rb_define_const(rb_cBigDecimal, "INFINITY", BIGDECIMAL_LITERAL(POSITIVE_INFINITY, +Infinity));
 
     /* Negative infinity value. */
-    arg = rb_str_new2("-Infinity");
-    BIGDECIMAL_NEGATIVE_INFINITY = f_BigDecimal(1, &arg, rb_cBigDecimal);
-    rb_gc_register_mark_object(BIGDECIMAL_NEGATIVE_INFINITY);
-
-    /* 'Not a Number' value. */
-    arg = rb_str_new2("NaN");
-    BIGDECIMAL_NAN = f_BigDecimal(1, &arg, rb_cBigDecimal);
-    rb_gc_register_mark_object(BIGDECIMAL_NAN);
+    BIGDECIMAL_LITERAL(NEGATIVE_INFINITY, -Infinity);
 
-    /* Special value constants */
-    rb_define_const(rb_cBigDecimal, "INFINITY", BIGDECIMAL_POSITIVE_INFINITY);
-    rb_define_const(rb_cBigDecimal, "NAN", BIGDECIMAL_NAN);
+    /* '{Not a Number}[rdoc-ref:BigDecimal@Not+a+Number]' value. */
+    rb_define_const(rb_cBigDecimal, "NAN", BIGDECIMAL_LITERAL(NAN, NaN));
 
     /* instance methods */
     rb_define_method(rb_cBigDecimal, "precs", BigDecimal_prec, 0);
@@ -5203,6 +5184,48 @@ bigdecimal_parse_special_string(const char *str)
     return NULL;
 }
 
+struct VpCtoV_args {
+  Real *a;
+  const char *int_chr;
+  size_t ni;
+  const char *frac;
+  size_t nf;
+  const char *exp_chr;
+  size_t ne;
+};
+
+static VALUE
+call_VpCtoV(VALUE arg)
+{
+  struct VpCtoV_args *x = (struct VpCtoV_args *)arg;
+  return (VALUE)VpCtoV(x->a, x->int_chr, x->ni, x->frac, x->nf, x->exp_chr, x->ne);
+}
+
+static int
+protected_VpCtoV(Real *a, const char *int_chr, size_t ni, const char *frac, size_t nf, const char *exp_chr, size_t ne, int free_on_error)
+{
+  struct VpCtoV_args args;
+  int state = 0;
+
+  args.a = a;
+  args.int_chr = int_chr;
+  args.ni = ni;
+  args.frac = frac;
+  args.nf = nf;
+  args.exp_chr = exp_chr;
+  args.ne = ne;
+
+  VALUE result = rb_protect(call_VpCtoV, (VALUE)&args, &state);
+  if (state) {
+    if (free_on_error) {
+      rbd_free_struct(a);
+    }
+    rb_jump_tag(state);
+  }
+
+  return (int)result;
+}
+
 /*
  * Allocates variable.
  * [Input]
@@ -5220,7 +5243,7 @@ VP_EXPORT Real *
 VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
 {
     const char *orig_szVal = szVal;
-    size_t i, j, ni, ipf, nf, ipe, ne, dot_seen, exp_seen, nalloc;
+    size_t i, j, ni, ipf, nf, ipe, ne, exp_seen, nalloc;
     size_t len;
     char v, *psz;
     int  sign=1;
@@ -5306,13 +5329,11 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
     ne  = 0; /* number of digits in the exponential part */
     ipf = 0; /* index of the beginning of the fractional part */
     ipe = 0; /* index of the beginning of the exponential part */
-    dot_seen = 0;
     exp_seen = 0;
 
     if (v != '\0') {
         /* Scanning fractional part */
         if ((psz[i] = szVal[j]) == '.') {
-            dot_seen = 1;
             ++i;
             ++j;
             ipf = i;
@@ -5328,9 +5349,6 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
                     }
                     if (!strict_p) {
                         v = psz[i] = '\0';
-                        if (nf == 0) {
-                            dot_seen = 0;
-                        }
                         break;
                     }
                     goto invalid_value;
@@ -5401,7 +5419,7 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
 
     psz[i] = '\0';
 
-    if (strict_p && (((ni == 0 || dot_seen) && nf == 0) || (exp_seen && ne == 0))) {
+    if (strict_p && ((ni == 0 && nf == 0) || (exp_seen && ne == 0))) {
         VALUE str;
       invalid_value:
         if (!strict_p) {
@@ -5422,7 +5440,7 @@ VpAlloc(size_t mx, const char *szVal, int strict_p, int exc)
     vp = rbd_allocate_struct(len);
     vp->MaxPrec = len;        /* set max precision */
     VpSetZero(vp, sign);
-    VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne);
+    protected_VpCtoV(vp, psz, ni, psz + ipf, nf, psz + ipe, ne, true);
     rb_str_resize(buf, 0);
     return vp;
 }
@@ -6112,7 +6130,7 @@ VpDivd(Real *c, Real *r, Real *a, Real *b)
     word_c = c->MaxPrec;
     word_r = r->MaxPrec;
 
-    if (word_a >= word_r) goto space_error;
+    if (word_a >= word_r || word_b + word_c - 2 >= word_r) goto space_error;
 
     ind_r = 1;
     r->frac[0] = 0;

data/ext/bigdecimal/extconf.rb

@@ -24,15 +24,17 @@ have_header("math.h")
 have_header("stdbool.h")
 have_header("stdlib.h")
 
-have_header("x86intrin.h")
-have_func("_lzcnt_u32", "x86intrin.h")
-have_func("_lzcnt_u64", "x86intrin.h")
-
-have_header("intrin.h")
-have_func("__lzcnt", "intrin.h")
-have_func("__lzcnt64", "intrin.h")
-have_func("_BitScanReverse", "intrin.h")
-have_func("_BitScanReverse64", "intrin.h")
+if have_header("x86intrin.h")
+  have_func("_lzcnt_u32", "x86intrin.h")
+  have_func("_lzcnt_u64", "x86intrin.h")
+end
+
+if have_header("intrin.h")
+  have_func("__lzcnt", "intrin.h")
+  have_func("__lzcnt64", "intrin.h")
+  have_func("_BitScanReverse", "intrin.h")
+  have_func("_BitScanReverse64", "intrin.h")
+end
 
 have_func("labs", "stdlib.h")
 have_func("llabs", "stdlib.h")

data/ext/bigdecimal/missing.c

@@ -15,7 +15,8 @@
     _Pragma("GCC diagnostic push") \
     _Pragma("GCC diagnostic ignored \"-Wattributes\"") \
     __attribute__((__no_sanitize__(x))) y; \
-    _Pragma("GCC diagnostic pop")
+    _Pragma("GCC diagnostic pop") \
+    y
 #endif
 
 #undef strtod

data/lib/bigdecimal/math.rb

@@ -7,13 +7,12 @@ require 'bigdecimal'
 #   sqrt(x, prec)
 #   sin (x, prec)
 #   cos (x, prec)
-#   atan(x, prec)  Note: |x|<1, x=0.9999 may not converge.
+#   atan(x, prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
 # where:
 #   x    ... BigDecimal number to be computed.
-#            |x| must be small enough to get convergence.
 #   prec ... Number of digits to be obtained.
 #++
 #

data/lib/bigdecimal/util.rb

@@ -155,7 +155,7 @@ class Complex < Numeric
   # See also Kernel.BigDecimal.
   #
   def to_d(*args)
-    BigDecimal(self) unless self.imag.zero? # to raise eerror
+    BigDecimal(self) unless self.imag.zero? # to raise error
 
     if args.length == 0
       case self.real

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: bigdecimal
 version: !ruby/object:Gem::Version
-  version: 3.1.7
+  version: 3.2.0
 platform: ruby
 authors:
 - Kenta Murata
 - Zachary Scott
 - Shigeo Kobayashi
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-14 00:00:00.000000000 Z
+date: 2025-05-29 00:00:00.000000000 Z
 dependencies: []
 description: This library provides arbitrary-precision decimal floating-point number
   class.
@@ -44,7 +45,9 @@ homepage: https://github.com/ruby/bigdecimal
 licenses:
 - Ruby
 - BSD-2-Clause
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/ruby/bigdecimal/blob/master/CHANGES.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -59,7 +62,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.5.10
+signing_key:
 specification_version: 4
 summary: Arbitrary-precision decimal floating-point number library.
 test_files: []