bigdecimal-pure 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0062663b0a3bfb0ae8756397f9e02443c49dacb965a6a3da25e01d39c7554a
-  data.tar.gz: 703b2fb877149972cf23ad3f5b0791510d4f5ed6932f3c8f5134d8c0053a37cd
+  metadata.gz: cf29bb03b15bb0bb1cbe340b2bc5a861f691af86d725f0d05122874ed2daeb64
+  data.tar.gz: 604104049ea023a06615056a809cd806ac446e7214d2ac8164002b4a232068ab
 SHA512:
-  metadata.gz: 2e60b3c1dc4e26635a84add8eabbdfecb67007be7764318fbbcaaa38c3b9df14129c16e9686a090bbf5848c4b2501e3f629c03c1cdb72c96ab46e5b26bb8b9eb
-  data.tar.gz: 9e23c4e38485648472c94c441199de7cc6a306b014d5b2653fa899a257b6c2a258716e512704e1dcc4b38fc833d49db3c2d82e8c5ebacf5e192f5f621c62b7aa
+  metadata.gz: b15e47a6978178e1199b4d51403b5fb5dfe3e9728d5ec7e165c358a91bd956b31e391a48708e94c2225079790797d5840e2e32e92969c35c78900ec5c34d4180
+  data.tar.gz: ea5fe695be57c79f4d3e45c5a609ffc8fec9464f025059c15dcedf8ed625dbc3ced159b5c0a7717161fa21295f741f191d4b987422571b8326e737cc45e15696

data/CHANGELOG.md

@@ -1,8 +1,36 @@
 # Changelog
 
+## [0.2.0] - 2026-09-30
+
+The pure class now does what bigdecimal 4.x does, where 0.1.0 did not:
+
+- NaN, `Infinity`, `-Infinity` and `-0`, with `BigDecimal::NAN` and
+  `BigDecimal::INFINITY`. `1 / 0` is `Infinity` and `0 / 0` is `NaN`, as in
+  the C version; 0.1.0 raised `ZeroDivisionError`.
+- `BigDecimal.mode` for the exception modes and the rounding mode, and
+  `BigDecimal.limit`, per thread, with the `save_*` blocks.
+- The precision of each result as in C: `/` keeps the larger operand's
+  precision plus 16 digits, at least 32 (0.1.0 used 20); Rational operands;
+  `add/sub/mult/div` with a precision; `sqrt(0)`; `power`.
+- `BigMath` to any precision; 0.1.0 went through Float and was good to about
+  15 digits. Also the functions bigdecimal 4.x added: `cbrt`, `hypot`, `tan`,
+  `asin`, `acos`, `atan2`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`,
+  `log2`, `log10`, `log1p`, `expm1`, `erf`, `erfc`, `gamma`, `lgamma`,
+  `frexp`, `ldexp`.
+- `BigDecimal(float, digits)`, division and `ROUND_UP` round exactly as the C
+  version does, down to its 9-digit words.
+- `BigDecimal.interpret_loosely`, every `to_s` format, `precision_scale`,
+  `n_significant_digits`, `split`, `_decimal_shift`.
+- As in 4.x, `sqrt` needs its precision and `precs` is gone.
+
+`test/compare_test.rb` runs about 8,500 expressions with the native and the
+pure class and compares every result; `test/wasm_test.rb` runs them in
+ruby.wasm.
+
 ## [0.1.0] - 2026-09-30
 
 - First release: BigDecimal in pure Ruby on Rational, taken from the ruby.wasm
   sandbox of Ren. `require 'bigdecimal'` prefers the native gem when installed.
 
+[0.2.0]: https://github.com/Largo/bigdecimal-pure/releases/tag/v0.2.0
 [0.1.0]: https://github.com/Largo/bigdecimal-pure/releases/tag/v0.1.0

data/README.md

@@ -11,8 +11,10 @@ gem 'bigdecimal-pure'
 ```ruby
 require 'bigdecimal'        # native if available, pure Ruby otherwise
 require 'bigdecimal/util'   # to_d, either way
+require 'bigdecimal/math'   # BigMath, either way
 
 BigDecimal('0.1') + BigDecimal('0.2')  # => 0.3e0
+BigMath.PI(50)                          # => 0.31415926535897932384626433832795028841971693993751e1
 BigDecimalPure.pure?                    # which one you got
 ```
 
@@ -29,20 +31,61 @@ load path that is not this gem's; on old Rubies it falls back to
 
 ## What the pure class does
 
-Built on `Rational`, so it is exact where BigDecimal is exact:
-
-- decimal strings (`"0.1" + "0.2"` is `0.3`), `+ - *`, rounding;
-- division and `sqrt` to 20 significant digits by default, like the original;
-- `round/floor/ceil/truncate` with digits and all `ROUND_*` modes;
-- `to_s` as `0.123e1`, `to_s('F')` as `1.23`; comparisons with Integer, Float
-  and Rational; `to_d` from `bigdecimal/util`; `Marshal`.
-
-Not supported: NaN and Infinity (they raise), `BigDecimal.limit` and `.mode`,
-precision bookkeeping. `BigMath` goes through Float, so it is good to about 15
-digits whatever precision is asked for.
-
-Unlike [hanami-wasm's shim](https://github.com/katafrakt/hanami-wasm)
-(`BigDecimal(v) = v.to_i`), the value is kept: `BigDecimal("0.1")` is not 0.
+What bigdecimal 4.x does, with the same results:
+
+- decimal strings exactly (`"0.1" + "0.2"` is `0.3`), with the same grammar
+  as the C version, `BigDecimal.interpret_loosely` and `String#to_d`;
+- NaN, `Infinity`, `-Infinity` and `-0`: `1 / 0` is `Infinity`, `0 / 0` is
+  `NaN`, and `BigDecimal.mode` turns each of them into an exception;
+- `BigDecimal.mode(BigDecimal::ROUND_MODE, ...)` and `BigDecimal.limit`, per
+  thread, with `save_exception_mode`, `save_rounding_mode` and `save_limit`;
+- the precision of each result: `+ - *` are exact unless a limit or a
+  precision argument says otherwise, `/` keeps the larger operand's precision
+  plus 16 digits (at least 32), a Rational operand is converted to as many
+  digits as the C version uses, `add/sub/mult/div(x, digits)` round to that;
+- `round/floor/ceil/truncate` with digits, every `ROUND_*` mode and `half:`;
+  `%`, `divmod`, `remainder`; `**` and `power`, exact for Integer powers;
+  `sqrt(digits)`, exact when the root is;
+- `to_s` in every format (`'F'`, `'E'`, digit groups, `'+'`, `' '`),
+  `precision`, `scale`, `n_significant_digits`, `exponent`, `split`,
+  `_dump`/`_load` for `Marshal`, comparisons and coercion with Integer, Float,
+  Rational and Complex;
+- `BigDecimal(float, digits)` digit for digit as the C version, which rounds
+  with the dtoa of Ruby and inherits its one-half shortcut;
+- `BigMath` to any precision: `exp`, `log`, `log2`, `log10`, `log1p`, `expm1`,
+  `sqrt`, `cbrt`, `hypot`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`,
+  `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `erf`, `erfc`, `gamma`,
+  `lgamma`, `frexp`, `ldexp`, `PI` and `E`.
+
+The C version keeps its digits in 9-digit words, and a few results show it:
+the precision of a Rational operand, the prefix of `_dump`, `ROUND_UP` to a
+position far left of the number, and division, which rounds from the words
+it has computed. The pure class counts those words too.
+
+### Where the two can differ
+
+- `BigMath` computes each result with 24 more digits and rounds once; the C
+  version rounds after every step and carries 16. When the exact value lies
+  closer than about 10**-(prec + 16) to a number of `prec` digits — in a
+  rounding mode other than the half modes, or for an argument so small that
+  the result is nearly the argument or nearly 1 — the last digit can differ
+  by one. Where that happened in the tests, the pure result was the correct
+  one: `BigMath.cos(0, 10)` in `ROUND_DOWN` is `1`, the C version says
+  `0.9999999999`.
+- `hash` values differ, and the C version's debugging methods (`vpdivd`,
+  `vpmult`, ...) and its internal `BigDecimal::Internal` are not there.
+- It is Ruby: basic operations take a few microseconds instead of a fraction
+  of one. BigMath works on Integers and keeps up with the C version's, which
+  is Ruby too: faster at 50 digits, about even at 500 (gamma a little
+  slower).
+
+## Thanks
+
+This gem only stands in where the real one cannot run. The real one is
+[ruby/bigdecimal](https://github.com/ruby/bigdecimal), and its behaviour is
+what this gem copies. Thank you to its authors and maintainers: Shigeo
+Kobayashi, who wrote it, Kenta Murata, Zachary Scott, tompng, and everyone
+who has contributed to it.
 
 ## Tests
 
@@ -50,6 +93,13 @@ Unlike [hanami-wasm's shim](https://github.com/katafrakt/hanami-wasm)
 bundle exec rake
 ```
 
+runs the pure class against known values, checks that the native one loads
+when it is there, and runs about 8,500 expressions with both and compares
+every result, error class and message (`test/compare_test.rb`; more with
+`CASES_SEED=7 CASES_SCALE=5`). `bundle exec rake wasm` runs the same
+expressions in ruby.wasm under node, with `RUBY_WASM_DIST` pointing to the
+`dist` directory of the npm package `@ruby/4.0-wasm-wasi`.
+
 ## License
 
 MIT

data/lib/bigdecimal/pure.rb

@@ -1,327 +1,17 @@
 # frozen_string_literal: true
 
-# BigDecimal in pure Ruby, on top of Rational. lib/bigdecimal.rb loads this only
-# when no native bigdecimal can be found (ruby.wasm, sandboxes without a
-# compiler). Require it directly to get the pure version regardless.
+# BigDecimal in pure Ruby. lib/bigdecimal.rb loads this only when no native
+# bigdecimal can be found (ruby.wasm, sandboxes without a compiler). Require
+# it directly to get the pure version regardless.
 #
-# Like the C version: decimal strings exactly ("0.1" + "0.2" is 0.3), + - *
-# exactly, division and sqrt to 20 significant digits by default,
-# round/floor/ceil/truncate with digits and the ROUND_* modes, to_s ("0.3e0",
-# or "0.3" with to_s('F')), comparisons with Integer, Float and Rational, to_d.
-# Not: NaN and Infinity (they raise), BigDecimal.limit and .mode, precision
-# bookkeeping. BigMath goes through Float, so it is good to about 15 digits.
+# It behaves like bigdecimal 4.x: NaN, the infinities and -0, BigDecimal.mode
+# and BigDecimal.limit, the precision rules of each operation, and BigMath to
+# any precision. bigdecimal/util and bigdecimal/math come with it.
 
 require_relative '../bigdecimal_pure/version'
 
 return if defined?(BigDecimal)
 
-# rubocop:disable Lint/BigDecimalNew, Naming/PredicateMethod, Style/ReturnNilInPredicateMethodDefinition
-# -- this is BigDecimal: .new is its own constructor, and infinite?/nonzero? answer
-# nil as the C version does.
-class BigDecimal < Numeric
-  ROUND_MODE = 256
-  ROUND_UP = 1
-  ROUND_DOWN = 2
-  ROUND_HALF_UP = 3
-  ROUND_HALF_DOWN = 4
-  ROUND_CEILING = 5
-  ROUND_FLOOR = 6
-  ROUND_HALF_EVEN = 7
-  SIGN_POSITIVE_ZERO = 1
-  SIGN_NEGATIVE_ZERO = -1
-  SIGN_POSITIVE_FINITE = 2
-  SIGN_NEGATIVE_FINITE = -2
-  DIV_DIGITS = 20
-  VERSION = BigDecimalPure::VERSION
-  PURE = true
-
-  DECIMAL = /\A\s*([+-]?)(\d[\d_]*)?(?:\.(\d[\d_]*)?)?(?:[eEdD]([+-]?\d+))?\s*\z/
-
-  attr_reader :rational
-  protected :rational
-
-  def self.parse(text)
-    match = DECIMAL.match(text)
-    if match.nil? || (match[2].nil? && match[3].nil?)
-      raise ArgumentError, "invalid value for BigDecimal(): #{text.inspect}"
-    end
-
-    whole = match[2].to_s.delete('_')
-    fraction = match[3].to_s.delete('_')
-    digits = Integer("#{whole}#{fraction}".sub(/\A0+(?=\d)/, '').then { |s| s.empty? ? '0' : s }, 10)
-    value = Rational(digits, 10**fraction.length) * (Rational(10)**match[4].to_i)
-    match[1] == '-' ? -value : value
-  end
-
-  def self.from(value, digits = 0)
-    case value
-    when BigDecimal then value
-    when Integer then new(Rational(value))
-    when Rational then new(digits.positive? ? round_significant(value, digits) : value)
-    when Float
-      raise FloatDomainError, value.to_s unless value.finite?
-
-      new(digits.positive? ? round_significant(value.to_r, digits) : parse(value.to_s))
-    when String then new(parse(value))
-    else
-      raise TypeError, "can't convert #{value.class} into BigDecimal" unless value.respond_to?(:to_r)
-
-      new(value.to_r)
-    end
-  end
-
-  # Rounds to `digits` significant digits, half up.
-  def self.round_significant(value, digits)
-    return Rational(0) if value.zero?
-
-    exponent = Math.log10(value.abs.to_f).floor rescue 0 # rubocop:disable Style/RescueModifier
-    scale = digits - exponent - 1
-    Rational((value * (Rational(10)**scale)).round, 1) / (Rational(10)**scale)
-  end
-
-  def self.double_fig = 16
-  def self.limit(*) = 0
-  def self.mode(*) = 0
-  def self.save_rounding_mode = yield
-  def self.save_exception_mode = yield
-  def self.save_limit = yield
-
-  def initialize(rational)
-    super()
-    @rational = rational
-    freeze
-  end
-
-  def to_r = @rational
-  def to_i = @rational.truncate
-  alias to_int to_i
-  def to_f = @rational.to_f
-  def to_d = self
-  def zero? = @rational.zero?
-  def nonzero? = zero? ? nil : self
-  def negative? = @rational.negative?
-  def positive? = @rational.positive?
-  def finite? = true
-  def infinite? = nil
-  def nan? = false
-  def integer? = false
-  def real? = true
-  def hash = @rational.hash
-  def precs = [digits_of.length, digits_of.length + DIV_DIGITS]
-  def precision = digits_of.length
-  def exponent = zero? ? 0 : Math.log10(@rational.abs.to_f).floor + 1
-
-  def sign
-    if zero? then SIGN_POSITIVE_ZERO
-    else negative? ? SIGN_NEGATIVE_FINITE : SIGN_POSITIVE_FINITE
-    end
-  end
-
-  def coerce(other) = [BigDecimal.from(other), self]
-  def -@ = BigDecimal.new(-@rational)
-  def +@ = self
-  def abs = BigDecimal.new(@rational.abs)
-
-  def +(other) = BigDecimal.new(@rational + value_of(other))
-  def -(other) = BigDecimal.new(@rational - value_of(other))
-  def *(other) = BigDecimal.new(@rational * value_of(other))
-
-  def /(other)
-    divisor = value_of(other)
-    raise ZeroDivisionError, 'divided by 0' if divisor.zero?
-
-    exact = @rational / divisor
-    terminating?(exact) ? BigDecimal.new(exact) : BigDecimal.new(BigDecimal.round_significant(exact, DIV_DIGITS))
-  end
-  alias quo /
-
-  def add(other, digits) = limit(self + other, digits)
-  def sub(other, digits) = limit(self - other, digits)
-  def mult(other, digits) = limit(self * other, digits)
-
-  def div(other, digits = nil)
-    return (self / other).floor if digits.nil?
-
-    divisor = value_of(other)
-    raise ZeroDivisionError, 'divided by 0' if divisor.zero?
-
-    digits.zero? ? self / other : BigDecimal.new(BigDecimal.round_significant(@rational / divisor, digits))
-  end
-
-  def %(other) = BigDecimal.new(@rational % value_of(other))
-  alias modulo %
-  def remainder(other) = BigDecimal.new(@rational.remainder(value_of(other)))
-  def divmod(other) = [div(other), self % other]
-
-  def **(other)
-    return BigDecimal.new(@rational**other) if other.is_a?(Integer)
-
-    BigDecimal.from(to_f**other.to_f, DIV_DIGITS)
-  end
-  alias power **
-
-  def sqrt(digits = DIV_DIGITS)
-    raise FloatDomainError, 'sqrt of negative value' if negative?
-
-    BigDecimal.from(Math.sqrt(to_f), [digits, 15].min)
-  end
-
-  def <=>(other)
-    other.is_a?(Numeric) ? @rational <=> value_of(other) : nil
-  end
-
-  def ==(other) = other.is_a?(Numeric) && @rational == value_of(other)
-  alias eql? ==
-  alias === ==
-  include Comparable
-
-  # Without digits an Integer, as in the C version; with digits a BigDecimal.
-  def round(*args, half: nil)
-    digits = args[0].is_a?(Integer) ? args[0] : 0
-    half = { up: ROUND_HALF_UP, down: ROUND_HALF_DOWN, even: ROUND_HALF_EVEN }[half]
-    mode = args.find { |arg| arg.is_a?(Symbol) } || (args[1].is_a?(Integer) ? args[1] : nil) || half || ROUND_HALF_UP
-    rounded = round_to(digits, mode)
-    args.empty? ? rounded.to_i : rounded
-  end
-
-  def floor(digits = 0) = digits.zero? ? @rational.floor : round_to(digits, ROUND_FLOOR)
-  def ceil(digits = 0) = digits.zero? ? @rational.ceil : round_to(digits, ROUND_CEILING)
-  def truncate(digits = 0) = digits.zero? ? @rational.truncate : round_to(digits, ROUND_DOWN)
-  alias fix truncate
-
-  def frac = BigDecimal.new(@rational - @rational.truncate)
-
-  # "0.123e1" like the C version; to_s('F') for plain notation.
-  def to_s(format = nil)
-    return plain if format.to_s.upcase.include?('F')
-    return '0.0' if zero?
-
-    digits = digits_of
-    "#{'-' if negative?}0.#{digits}e#{exponent_of}"
-  end
-
-  def inspect = to_s
-  def to_digits = plain
-
-  def _dump(_level = 0) = to_s
-  def self._load(text) = from(text)
-
-  private
-
-  def value_of(other)
-    case other
-    when BigDecimal then other.rational
-    when Integer, Rational then other.to_r
-    when Float
-      raise FloatDomainError, other.to_s unless other.finite?
-
-      BigDecimal.parse(other.to_s)
-    else
-      raise TypeError, "#{other.class} can't be coerced into BigDecimal" unless other.respond_to?(:to_r)
-
-      other.to_r
-    end
-  end
-
-  def limit(value, digits)
-    digits.to_i.positive? ? BigDecimal.new(BigDecimal.round_significant(value.to_r, digits.to_i)) : value
-  end
-
-  def terminating?(value)
-    denominator = value.denominator
-    denominator /= 2 while (denominator % 2).zero?
-    denominator /= 5 while (denominator % 5).zero?
-    denominator == 1
-  end
-
-  # All significant digits, without leading or trailing zeros.
-  def digits_of
-    text = plain.delete('-').delete('.').sub(/\A0+/, '').sub(/0+\z/, '')
-    text.empty? ? '0' : text
-  end
-
-  def exponent_of
-    whole, fraction = plain.delete('-').split('.')
-    return whole.length if whole != '0'
-
-    -(fraction.length - fraction.sub(/\A0+/, '').length)
-  end
-
-  # Plain decimal notation. Every value here terminates: strings, Integers and
-  # Floats parse to finite decimals, and division rounds when it would not.
-  def plain
-    value = @rational.abs
-    scale = 0
-    scale += 1 until (value * (10**scale)).denominator == 1 || scale > 1000
-    digits = (value * (10**scale)).round.to_s.rjust(scale + 1, '0')
-    whole = digits[0...(digits.length - scale)]
-    fraction = scale.zero? ? '0' : digits[(digits.length - scale)..].sub(/0+\z/, '')
-    fraction = '0' if fraction.empty?
-    "#{'-' if negative?}#{whole}.#{fraction}"
-  end
-
-  def round_to(digits, mode)
-    scale = Rational(10)**digits
-    scaled = @rational * scale
-    whole = case mode
-            when ROUND_UP, :up then scaled.negative? ? scaled.floor : scaled.ceil
-            when ROUND_DOWN, :down, :truncate then scaled.truncate
-            when ROUND_CEILING, :ceiling, :ceil then scaled.ceil
-            when ROUND_FLOOR, :floor then scaled.floor
-            when ROUND_HALF_DOWN, :half_down then half(scaled, :down)
-            when ROUND_HALF_EVEN, :half_even, :banker then half(scaled, :even)
-            else scaled.round(half: :up)
-            end
-    BigDecimal.new(Rational(whole) / scale)
-  end
-
-  def half(scaled, way) = scaled.round(half: way)
-end
-# rubocop:enable Lint/BigDecimalNew, Naming/PredicateMethod, Style/ReturnNilInPredicateMethodDefinition
-
-module Kernel
-  def BigDecimal(value, digits = 0, exception: true) # rubocop:disable Naming/MethodName
-    BigDecimal.from(value, digits)
-  rescue ArgumentError, TypeError
-    raise if exception
-
-    nil
-  end
-  module_function :BigDecimal
-  public :BigDecimal
-end
-
-# bigdecimal/util: to_d on the numbers and strings.
-class Integer
-  def to_d = BigDecimal(self)
-end
-
-class Float
-  def to_d(digits = 0) = BigDecimal(self, digits)
-end
-
-class Rational
-  def to_d(digits) = BigDecimal(self, digits)
-end
-
-class String
-  def to_d = BigDecimal(self, exception: false) || BigDecimal(0)
-end
-
-class NilClass
-  def to_d = BigDecimal(0)
-end
-
-# bigdecimal/math, through Float: about 15 good digits whatever is asked for.
-module BigMath
-  module_function
-
-  def exp(value, digits) = BigDecimal(Math.exp(value.to_f), [digits, 15].min)
-  def log(value, digits) = BigDecimal(Math.log(value.to_f), [digits, 15].min)
-  def sqrt(value, digits) = BigDecimal(value).sqrt(digits)
-  def PI(digits) = BigDecimal(Math::PI, [digits, 15].min) # rubocop:disable Naming/MethodName
-  def E(digits) = BigDecimal(Math::E, [digits, 15].min) # rubocop:disable Naming/MethodName
-  def sin(value, digits) = BigDecimal(Math.sin(value.to_f), [digits, 15].min)
-  def cos(value, digits) = BigDecimal(Math.cos(value.to_f), [digits, 15].min)
-  def atan(value, digits) = BigDecimal(Math.atan(value.to_f), [digits, 15].min)
-end
+require_relative '../bigdecimal_pure/decimal'
+require_relative '../bigdecimal_pure/math'
+require_relative '../bigdecimal_pure/util'