bigdecimal-pure 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc0062663b0a3bfb0ae8756397f9e02443c49dacb965a6a3da25e01d39c7554a
+  data.tar.gz: 703b2fb877149972cf23ad3f5b0791510d4f5ed6932f3c8f5134d8c0053a37cd
+SHA512:
+  metadata.gz: 2e60b3c1dc4e26635a84add8eabbdfecb67007be7764318fbbcaaa38c3b9df14129c16e9686a090bbf5848c4b2501e3f629c03c1cdb72c96ab46e5b26bb8b9eb
+  data.tar.gz: 9e23c4e38485648472c94c441199de7cc6a306b014d5b2653fa899a257b6c2a258716e512704e1dcc4b38fc833d49db3c2d82e8c5ebacf5e192f5f621c62b7aa

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## [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.1.0]: https://github.com/Largo/bigdecimal-pure/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# bigdecimal-pure
+
+BigDecimal in pure Ruby, for places where the C extension cannot run —
+ruby.wasm above all. Where the native `bigdecimal` gem is installed, it wins
+automatically.
+
+```ruby
+gem 'bigdecimal-pure'
+```
+
+```ruby
+require 'bigdecimal'        # native if available, pure Ruby otherwise
+require 'bigdecimal/util'   # to_d, either way
+
+BigDecimal('0.1') + BigDecimal('0.2')  # => 0.3e0
+BigDecimalPure.pure?                    # which one you got
+```
+
+`require 'bigdecimal/pure'` loads the pure class unconditionally (unless a
+BigDecimal is already defined). `BIGDECIMAL_PURE=1` makes `require 'bigdecimal'`
+skip the native one.
+
+## How the native one is found
+
+`require 'bigdecimal'` activates the `bigdecimal` gem if it is installed (under
+Bundler: if it is in the bundle), then loads the first `bigdecimal.rb` on the
+load path that is not this gem's; on old Rubies it falls back to
+`bigdecimal.so`. Only when all of that fails does the pure class load.
+
+## 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.
+
+## Tests
+
+```
+bundle exec rake
+```
+
+## License
+
+MIT

data/lib/bigdecimal/math.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# `require 'bigdecimal/math'`: the native file with the native bigdecimal. The
+# pure class defines everything of bigdecimal/math itself.
+require_relative '../bigdecimal'
+
+BigDecimalPure.require_native('bigdecimal/math') unless BigDecimalPure.pure?

data/lib/bigdecimal/pure.rb

@@ -0,0 +1,327 @@
+# 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.
+#
+# 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.
+
+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

data/lib/bigdecimal/util.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# `require 'bigdecimal/util'`: the native file with the native bigdecimal. The
+# pure class defines everything of bigdecimal/util itself.
+require_relative '../bigdecimal'
+
+BigDecimalPure.require_native('bigdecimal/util') unless BigDecimalPure.pure?

data/lib/bigdecimal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# `require 'bigdecimal'`: the native bigdecimal when it is installed, else the
+# pure Ruby one from this gem.
+require_relative 'bigdecimal_pure'
+
+require_relative 'bigdecimal/pure' unless defined?(BigDecimal) || BigDecimalPure.require_native('bigdecimal')

data/lib/bigdecimal_pure/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BigDecimalPure
+  VERSION = '0.1.0'
+end

data/lib/bigdecimal_pure.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'bigdecimal_pure/version'
+
+# Finds the native bigdecimal, if there is one, so that `require 'bigdecimal'`
+# gets it and this gem's pure Ruby class only fills in where it is missing.
+module BigDecimalPure
+  OWN_LIB = File.expand_path(__dir__)
+
+  module_function
+
+  # true once the pure class is the BigDecimal in use.
+  def pure? = defined?(::BigDecimal::PURE) ? true : false
+
+  # true when the native extension is the BigDecimal in use.
+  def native? = defined?(::BigDecimal) && !pure? ? true : false
+
+  # Loads the native `feature` ("bigdecimal", "bigdecimal/util", ...), or
+  # returns false when there is none. BIGDECIMAL_PURE=1 forces false.
+  def require_native(feature)
+    return false if ENV['BIGDECIMAL_PURE'] == '1'
+
+    activate_native_gem
+    path = native_path(feature)
+    if path
+      require path
+      true
+    elsif feature == 'bigdecimal'
+      require_native_extension
+    else
+      false
+    end
+  end
+
+  # The bigdecimal gem, installed next to this one: put its lib on the load
+  # path. Under Bundler this only works if it is in the bundle, which is right.
+  def activate_native_gem
+    return unless defined?(Gem) && Gem.respond_to?(:try_activate)
+
+    gem 'bigdecimal'
+  rescue LoadError, StandardError
+    nil
+  end
+
+  # "<feature>.rb" anywhere on the load path except in this gem.
+  def native_path(feature)
+    $LOAD_PATH.each do |dir|
+      dir = File.expand_path(dir.to_s)
+      next if dir == OWN_LIB
+
+      candidate = File.join(dir, "#{feature}.rb")
+      return candidate if File.file?(candidate)
+    end
+    nil
+  end
+
+  # Old Rubies ship only bigdecimal.so, without a Ruby part.
+  def require_native_extension
+    require 'bigdecimal.so'
+    true
+  rescue LoadError
+    false
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: bigdecimal-pure
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: "`require 'bigdecimal'` loads the native bigdecimal when it is installed
+  and a pure Ruby BigDecimal on Rational otherwise, for ruby.wasm and other places
+  without a C compiler."
+email:
+- andi@idogawa.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/bigdecimal.rb
+- lib/bigdecimal/math.rb
+- lib/bigdecimal/pure.rb
+- lib/bigdecimal/util.rb
+- lib/bigdecimal_pure.rb
+- lib/bigdecimal_pure/version.rb
+homepage: https://github.com/Largo/bigdecimal-pure
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Largo/bigdecimal-pure
+  changelog_uri: https://github.com/Largo/bigdecimal-pure/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: BigDecimal in pure Ruby, used only where the native one is missing.
+test_files: []