fixed 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e87ed315b7c15cb15aa8663e00e8090b29d352babf0d30191da6d16ccca1640
-  data.tar.gz: fb6001610413384c17bdd211bcbccd471c8e5c506e4c07bdabef3814903e11b3
+  metadata.gz: 61a3482844d4fbd66a1edb0dee9b686ba6a4662a289d9d165b7d35c63e5405f0
+  data.tar.gz: 123197024b596d6a549e7b1b72f9b900b1edf1d26579299648d468c858f6fb1b
 SHA512:
-  metadata.gz: 333bb7867bddec4a1939e205d35e5c05e0443dce411f766d263f3d27c573a54c93a8d021204fbc4edf0d4b0c255a99b6323332464dfbe7afc14a2fbe1a6cf6e9
-  data.tar.gz: edcda27654f5edce4d586d463d4f682e0f552a525eef203e68655efa751fbc2235437d34215332530e7cba0179420e366efa5146ef315deff24c6e53b687ee27
+  metadata.gz: e34d2f9c2fcf1a487f7f9c4e4630997e015c3253c470e00b1dfddc14687f657eba7293c2a3c065002a96f7377828173aa567feede0d45ce59cba2da4a1cbcf2b
+  data.tar.gz: f28a0c77579fb25a9501a2a7cd8a97225440f93bcb1020d3291828348f8f9865b8f6de8e0d93341da6589d19f2a9a8061cef751428d28db4df6234f791464195

data/README.md

@@ -25,21 +25,12 @@ Here's an example of how to use the Fixed gem:
 ```ruby
 require 'fixed'
 
-# Create Fixed instances
-a = Fixed(1)
-b = Fixed(6)
+a = Fixed(5)
+b = Fixed(3)
 
-# Perform arithmetic operations
-sum = a + b
-difference = a - b
-product = a * b
 ratio = a / b
 
-# Output the results
-puts "Sum: #{sum}"                  # => Sum: 7.00000000
-puts "Difference: #{difference}"    # => Difference: -5.00000000
-puts "Product: #{product}"          # => Product: 6.00000000
-puts "Ratio: #{ratio.format(18)}"   # => Ratio: 0.166666666666666667
+puts ratio.format(18) # => prints 1.666666666666666667
 ```
 
 In the above example, the Fixed gem allows you to perform arithmetic operations with high precision, avoiding rounding errors that can occur with floating-point numbers.

data/lib/fixed/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Fixed
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end
 
 
@@ -11,6 +11,12 @@ __END__
 # Minor version bump when backward-compatible changes or enhancements
 # Patch version bump when backward-compatible bug fixes, security updates etc
 
+1.1.0
+
+  - Support Ruby versions as old as 1.9.3
+  - Add #split for dividing a number proportionally based on specified ratios
+  - Add #pretty_format for printing with thousands separators
+
 1.0.0
 
   - Added Fixed-number with 18-digit precision

data/lib/fixed.rb

@@ -89,6 +89,31 @@ class Fixed
     make(self.fractions.abs)
   end
 
+  def split(*numbers)
+    ratios = numbers.map(&:to_fixed)
+    raise ArgumentError if ratios.any?(&:negative?)
+    raise ArgumentError if ratios.all?(&:zero?)
+
+    # This method ensures that the calculated portions add up to the original
+    # value and that no eps are lost due to rounding errors or other issues.
+
+    remainder = ratios.reduce(:+)
+    number = self
+
+    ratios.map do |ratio|
+      next Fixed.zero if remainder.zero?
+
+      part = make(division_with_rounding(
+        number.fractions * ratio.fractions,
+        remainder.fractions,
+      ))
+      remainder -= ratio
+      number -= part
+      part
+    end
+  end
+
+
   # ------- comparing -----------------------------------------------
 
   def <=>(number)
@@ -101,15 +126,15 @@ class Fixed
   end
 
   def negative?
-    self.fractions.negative?
+    @fractions < 0
   end
 
   def positive?
-    self.fractions.positive?
+    @fractions > 0
   end
 
   def zero?
-    self.fractions.zero?
+    @fractions == 0
   end
 
 
@@ -130,13 +155,23 @@ class Fixed
   def format(precision = 8)
     raise "expected 1..18, got #{precision.inspect}" unless (0..18) === precision
 
-    # Note: although Ruby's documentation indicates otherwise, Rational values
-    # are actually formatted with full precision rather than as floats.
+    rounded_fractions = division_with_rounding(@fractions, 10 ** (18 - precision))
+    str = rounded_fractions.abs.to_s.rjust(precision + 1, ?0)
+    str.insert(-1 - precision, ?.) if precision > 0
+    "#{?- if @fractions < 0}#{str}#{?* if @fractions != 0 && str =~ /^[-0\.]*$/}"
+  end
+
+  def pretty_format(precision = 8)
+    str = format(precision).dup
+    stop = negative? ? 4 : 3
 
-    str = "%.0#{precision}f" % Rational(@fractions, 1000000000000000000)
-    (str =~ /^-?0(\.0+)?$/ && @fractions != 0) ? str << ?* : str
+    n = str.index('.') || str.length
+    str.insert(n -= 3, ',') while n > stop
+
+    return str
   end
 
+
   # ------- serialization -------------------------------------------
 
   def to_json(state)
@@ -170,30 +205,36 @@ class Fixed
     # variables, and we found caching the special variables to be faster
     # (apparently new substrings are created upon each access), and also
     # we found string concatenation and converting integer only once to
-    # be faster than two conversions and arithmetic concatenation that
-    # correctly handles the sign for all negative numbers...
+    # be faster than two conversions and arithmetic operations.
 
     str =~ /\A(-?\d+)(?:\.(\d{1,18}))?\Z/
     whole, decimals = $1, $2
-    raise "expected number with up to 18 decimal places, got #{str.inspect}" unless whole
-    if decimals and decimals.length == 18
+    raise "expected valid string representation, got #{str.inspect}" unless whole
+
+    if decimals == nil
+      whole.to_i * 1000000000000000000
+    elsif decimals.length == 18
       "#{whole}#{decimals}".to_i
-    elsif decimals
-      "#{whole}#{decimals}".to_i * (10 ** (18 - decimals.length))
     else
-      whole.to_i * 1000000000000000000
+      "#{whole}#{decimals}".ljust(whole.length + 18, ?0).to_i
     end
   end
 
   def self.number_as_fractions(number)
     case number
     when Float
-      # This approach ensures consistency with the visible representation
-      # of floats by avoiding rounding errors that may occur if we simply
-      # multiply by 18 digits, considering that floats have only about
-      # 15 digits of precision (see unit tests for examples).
-
-      Integer Rational(number.to_s) * 1000000000000000000
+      # NOTE: Ensures consistency with the visible representation of floats
+      # to avoid rounding errors such as 16.50479841 => 1.6504798409999998976
+
+      number.to_s =~ /\A(-?\d+)(?:\.(\d+))(?:e([+-]\d+))?\Z/
+      whole, decimals, padding = $1, $2, $3.to_i + 18
+      raise "unsupported floating-point value: #{number}" unless whole
+
+      if padding < decimals.length
+        "#{whole}#{decimals}"[0..(padding - decimals.length - 1)].to_i
+      else
+        "#{whole}#{decimals}".ljust(whole.length + padding, ?0).to_i
+      end
     else
       Integer number * 1000000000000000000
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fixed
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Adrian Kuhn
@@ -35,7 +35,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="