numrepr 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1a48451e0600ba32b7e705a6182e152b79c65eb2e2cd5b8f5972d78dd7dfd1f
+  data.tar.gz: afe9490a19dc479341ccf3fa367c5496eac1cedc6cec8236db39b6645cd2cfe6
+SHA512:
+  metadata.gz: 68523527b522f8ea6beb3a29ff580b7cb27c19f7cf64ca3424a48b108f4ee1e1a5b8c1ec7360d702481f6dcadfbcfa3cb4699fd11cec6f704a428b4c530e0ba3
+  data.tar.gz: f59b0cfe695b372b506696816239bfd9b420b5d99ba849d7ec4dac340d8ef172e15b79a8b3b4fbf4dc80cb682c039b0d4d9fdc84cede39d7bc3205e143d6ab97

data/LICENSE

@@ -0,0 +1,52 @@
+# BSD-2-clause license, extended by language use conditions
+
+Copyright (C) 2026 Bertram Scharpf <software@bertram-scharpf.de>.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+
+  * Redistributions must not contain any clauses about anticipated
+    harassment or discrimination, nor must they be held in a so-called
+    "inclusive language". As far as German language is used, the
+    conditions mentioned below additionally apply.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## Use of the German Language
+
+Beim Gebrauch deutscher Sprache sind Weiterentwicklungen und
+-verbreitungen nur gestattet unter Einhaltung sowie abermaligen
+Einforderns folgender zusätzlicher Bedingungen:
+
+  * Keine Verwendung von sogenannter „geschlechtergerechter Sprache“,
+    also Anfügen von weiblichen Endungen mit Binnen-I, Sternchen,
+    Doppelpunkt, Unterstrich oder ähnlichem, oder Konstruktionen, die
+    den Sachverhalt falsch wiedergeben („Radfahrende“, „Studierende“).
+
+  * Keine Verwendung der „reformierten Rechtschreibung“ von 1996,
+    insbesondere Doppel-S am Silbenende, „plazieren“ mit T, sowie
+    Großschreibung von Wendungen wie „des weiteren“.
+
+
+<!-- vim:set ft=markdown : -->

data/README.md

@@ -0,0 +1,212 @@
+# Ruby-NumRepr
+
+Number representations: Conversion from and to strings for Integer, Float, and
+BigDecimal classes.
+
+Classes for monetary und percent values.
+
+
+
+## Installation
+
+```shell
+sudo gem install numrepr
+```
+
+
+## Usage
+
+Parsing and formatting integers:
+
+```ruby
+require "numrepr/format"
+
+i = NumRepr::Parser.into_i "12.345"
+"#{NumRepr::Format.from_i i}"   #=> "12345"
+```
+
+Custom format:
+
+```ruby
+require "numrepr/format"
+
+class MyFmt < NumRepr::Format
+  NUMDIGITS = 0       # leave empty if zero
+  GRP       = true
+  WIDTH     = 8
+end
+
+[ 12345, -12345, 0].map { |i| "#{MyFmt.from_i i}" }
+#=> ["  12,345", " -12,345", "        "]
+```
+
+The standard parser recognizes comma as decimal separator as well
+as the dot. You may define a custom parser that demands either.
+
+```ruby
+require "numrepr/format"
+
+%w(12,345 12.345).map { |s| NumRepr::Parser.into_i s }
+#=> [12345, 12345]
+
+class ParseDot < NumRepr::Parser
+  GRP = "."
+end
+class ParseComma < NumRepr::Parser
+  GRP = ","
+end
+
+%w(12,345 12.345).map { |s| ParseDot.into_i s   rescue nil }
+#=> [nil, 12345]
+%w(12,345 12.345).map { |s| ParseComma.into_i s rescue nil }
+#=> [12345, nil]
+```
+
+Parsing and formatting floats respectively decimals:
+
+```ruby
+require "numrepr/format"
+require "bigdecimal/util"
+
+class FormatCustom < NumRepr::Format
+  # Change these and see what happens:
+  NUMDIGITS = 10
+  POS       = false
+  GRP       = true
+  WIDTH     = 16
+  DEC       = true    # force decimal point
+  NUMPLACES = 0
+  RWIDTH    = 8
+  ZSIGN     = true
+end
+
+nums = %w(
+  1.0 0.0 -0.0
+  0.1 0.1234 0.00456 0.000456 0.0000456
+  123456789.0 1230000.0
+  -1234.56789
+  NaN Infinity -Infinity
+)
+
+nums.each { |s|
+  puts "|#{FormatCustom::from_d s.to_d}|"
+}
+```
+
+Result:
+
+```
+|   0,000,000,001.        |
+|   0,000,000,000.        |
+|  -0,000,000,000.        |
+|   0,000,000,000.1       |
+|   0,000,000,000.123,4   |
+|   0,000,000,000.004,56  |
+|   0,000,000,000.000,456 |
+|   0,000,000,000.000,045,6|
+|   0,123,456,789.        |
+|   0,001,230,000.        |
+|  -0,000,001,234.567,89  |
+|             NaN         |
+|             Inf         |
+|            -Inf         |
+```
+
+Parsing:
+
+```ruby
+require "numrepr/format"
+require "bigdecimal/util"
+
+%w(12,345.678,999 12.345,678.999).map { |s| NumRepr::Parser.into_d s }
+#=> [12345.678999, 12345.678999]
+
+class ParseDot < NumRepr::Parser
+  GRP = "."
+end
+
+%w(12,345.678,999 12.345,678.999).map { |s| ParseDot.into_d s rescue nil }
+#=> [nil, 12345.678999]
+```
+
+
+### Monetary values
+
+```ruby
+require "numrepr/money"
+include NumRepr
+
+class FormatEU < Format
+  CHDEC  = ","
+  GRP    = true
+  CHGRP  = "."
+  DASH   = true
+  CURSYM = "€"
+end
+
+amount = Parser.into_money "€  12,345.-"
+puts amount
+puts "|#{FormatEU::from_money amount}|"
+```
+
+Result:
+
+```
+$12345.00
+|€12.345,- |
+```
+
+Default parsing:
+
+```ruby
+require "numrepr/money"
+include NumRepr
+
+Parser.into_money "€  12,345.-"    #=> $12345.00
+Parser.into_money "€  12.345,-"    #=> $12345.00
+Parser.into_money "12.345,-€"      #=> $12345.00
+Parser.into_money "EUR  12.345,-"  #=> $12345.00
+Parser.into_money "12.345,-EUR"    #=> $12345.00
+Parser.into_money "12.345,67 EUR"  #=> $12345.67
+Parser.into_money "12.345,67€"     #=> $12345.67
+```
+
+
+### Percent values
+
+```ruby
+require "numrepr/money"
+require "numrepr/percent"
+include NumRepr
+
+vat = "19%".to_percent
+n = "100.00".to_money
+
+n * vat       #=>  $19.00
+vat.over n    #=> $119.00
+vat.split n   #=> [$84.03, $15.97]
+```
+
+If an amount cannot be split into a base and a percent increase,
+it can be forced to the next lower number.
+
+```ruby
+require "numrepr/money"
+require "numrepr/percent"
+include NumRepr
+
+vat = "19%".to_percent
+b = "69.99".to_money
+vat.split b             #=>  raises NoSolutionError
+n, t = vat.split! b     #=> [$58.82, $11.17]
+c = vat.over n          #=> $70.00
+vat.split c             #=> [$58.82, $11.18]
+```
+
+
+## Copyright
+
+  * (C) 2026 Bertram Scharpf <software@bertram-scharpf.de>.
+  * License: [BSD-2-Clause+](./LICENSE)
+  * Repository: [ruby-numrepr](https://github.com/BertramScharpf/ruby-numrepr)
+

data/lib/numrepr/decimal.rb

@@ -0,0 +1,296 @@
+#
+#  decimal.rb  --  Umlimited precision decimal
+#
+
+# This is just a study. Please use the standard +BigDecimal+.
+
+
+require "numrepr/format"
+
+
+module NumRepr
+
+  class Decimal
+
+    BASE = 10
+
+    @precision = 16
+
+    class <<self
+
+      attr_accessor :precision
+
+      alias parse new
+
+      def zero ; new nil ; end
+
+      def as obj
+        case obj
+        when self then obj
+        else           new obj
+        end
+      end
+
+    end
+
+    attr_reader :mant, :expo
+
+    def initialize mant, expo = nil
+      @mant, @expo =
+        case mant
+        when Integer  then [ mant, 0]
+        when Rational then parse_num mant.to_f
+        when Numeric  then parse_num mant
+        else               parse_str mant.to_s
+        end
+      @expo += expo.to_i if expo
+      norm!
+    rescue ArgumentError
+      raise ArgumentError, "Not a Decimal value: \"#{mant}\"."
+    end
+
+    def mag ; BASE ** @expo ; end
+    alias magnitude mag
+
+    private
+
+    def parse_num num
+      if num.respond_to? :split then  # Will there ever be something like this for Float?
+        _, dig, _, exp = num.split
+        [ dig.to_i, exp - dig.length]
+      else
+        parse_str num.to_s
+      end
+    end
+
+    def parse_str str
+      m, e = str.split /e/i, 2
+      e = e ? (Integer e, BASE) : 0
+      m.sub! %r/\./ do
+        e -= $'.count "0-9"
+        nil
+      end
+      [ (Integer m, BASE), e]
+    end
+
+    public
+
+    def eql? oth ; self.class == oth.class and @mant == oth.mant and @expo == oth.expo ; end
+
+    def hash ; [@mant,@expo].hash ; end
+
+    def to_decimal ; self ; end
+
+    def to_f ; @mant.to_f * mag ; end
+    def to_i ; Integer @mant * mag ; end
+    def to_r ; Rational @mant * mag ; end
+    def to_d ; @mant.to_d * mag ; end
+
+    def succ! ; add! 1 ; end
+    def pred! ; sub! 1 ; end
+    def succ ; dup.succ! ; end
+    def pred ; dup.pred! ; end
+
+    def zero?    ; @mant.zero? ; end
+    def nonzero? ; @mant.nonzero? and self ; end
+
+    def sign ; @mant ; end
+    def positive? ; @mant.positive? ; end
+    def negative? ; @mant.negative? ; end
+    alias pos? positive?
+    alias neg? negative?
+
+    private
+
+    def norm!
+      if @mant.zero? then
+        @expo = 0
+      else
+        loop do
+          m, r = @mant.divmod BASE
+          break if r.nonzero?
+          @mant = m
+          @expo += 1
+        end
+      end
+      self
+    end
+
+    def same_expo oth
+      oth = Decimal.new oth unless Decimal === oth
+      om, oe = oth.mant, oth.expo
+      while @expo > oe do
+        @mant *= BASE
+        @expo -= 1
+      end
+      while @expo < oe do
+        om *= BASE
+        oe -= 1
+      end
+      om
+    end
+
+    public
+
+    def add! oth ; m = same_expo oth ; @mant += m ; norm! ; end
+    def sub! oth ; m = same_expo oth ; @mant -= m ; norm! ; end
+    def add oth ; dup.add! oth ; end
+    def sub oth ; dup.sub! oth ; end
+
+    def mul! oth
+      oth = Decimal.new oth unless Decimal === oth
+      @mant *= oth.mant
+      @expo += oth.expo
+      norm!
+    end
+    def mul oth ; dup.mul! oth ; end
+
+    def div! oth, precision = 0
+      oth = Decimal.new oth unless Decimal === oth
+      @expo -= oth.expo
+      neg = @mant.negative?
+      @mant, n = 0, @mant.abs
+      t = (precision||self.class.precision).to_i
+      while t + @expo >= 0 do
+        n, r = n.divmod oth.mant
+        @mant += n
+        break if r.zero?
+        n = r
+        n     *= BASE
+        @mant *= BASE
+        @expo -= 1
+      end
+      @mant = -@mant if neg
+      norm!
+    end
+    def div oth, precision = 0 ; dup.div! oth, precision ; end
+
+    def quo! oth, precision = nil ; div! oth, precision ; end
+    def quo  oth, precision = nil ; dup.quo! oth, precision ; end
+
+    alias + add
+    alias - sub
+    alias * mul
+    alias / div
+
+    def neg! ; @mant = -@mant ; self ; end
+    def neg ; dup.neg! ; end
+    def +@ ; self ; end
+    def -@ ; neg  ; end
+
+    def abs ; self.class.new @mant.abs, @expo ; end
+
+    def <=> oth
+      case oth
+      when Decimal then (@expo <=> oth.expo).nonzero? || (@mant <=> oth.mant)
+      when Numeric then (@mant.to_f * 10 ** @expo) <=> oth
+      end
+    end
+    include Comparable
+
+    def coerce oth ; [ oth, to_r] ; end
+
+    def round! precision = nil, method = nil
+      s = -@expo - precision.to_i
+      if s <= 0 then
+        self
+      else
+        neg = @mant.negative?
+        g = BASE ** s
+        @mant, r = @mant.abs.divmod g
+        @expo += s
+        r *= 2
+        up =
+          case method||:comm
+          when :comm  then r >= g
+          when :stat  then r > g || r == g && @mant.odd?
+          when :trunc then false
+          when :ceil  then true
+          when :up    then !neg
+          when :down  then neg
+          else             raise ArgumentError, "Unknown rounding method: #{method}"
+          end
+        @mant += 1 if up
+        @mant = -@mant if neg
+        norm!
+      end
+    end
+    def round precision = nil, method = nil ; dup.round! precision, method ; end
+
+    def trunc! precision = nil ; round! precision, :trunc ; end
+    def trunc  precision = nil ; dup.trunc! precision ; end
+    def ceil!  precision = nil ; round! precision, :ceil  ; end
+    def ceil   precision = nil ; dup.ceil!  precision ; end
+
+    def make_digits
+      d, f = "", ""
+      n = @mant.abs
+      e = @expo < 0 ? @expo : 0
+      in_d = false
+      loop do
+        if e >= 0 then
+          in_d = true
+        end
+        if e < @expo then
+          r = 0
+        else
+          break if n.zero? and in_d
+          n, r = n.divmod 10
+        end
+        e += 1
+        (in_d ? d : f) << (r + "0".ord).chr
+      end
+      f.reverse!
+      [ d, f]
+    end
+
+    def raw
+      d, f = make_digits
+      d << "0" if d.empty?
+      d << "-" if negative?
+      d.reverse!
+      f.empty? or d << "." << f
+      d
+    end
+    alias to_s    raw
+    def inspect
+      r = @mant.to_s
+      r << "e" << @expo.to_s unless @expo.zero?
+      r
+    end
+
+  end
+
+  class Parser
+
+    class <<self
+
+      def into_decimal str
+        digs = prepare_float str
+        Decimal digs
+      rescue ArgumentError, NoMethodError
+        raise ArgumentError, "Couldn't parse as a decimal: #{str}"
+      end
+
+    end
+
+  end
+
+  class Format
+
+    class <<self
+      alias from_decimal from_d
+    end
+
+  end
+
+
+  def Decimal v ; Decimal.new v ; end
+
+end
+
+
+class NilClass ; def to_decimal ; NumRepr::Decimal.new self ; end ; end
+class Numeric  ; def to_decimal ; NumRepr::Decimal.new self ; end ; end
+class String   ; def to_decimal ; NumRepr::Decimal.new self ; end ; end
+