kgl 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89523b5350ef65694c439eca64804c5c89e2f450cd1b2fcb2fca9eaa466df07b
-  data.tar.gz: 3c104f76f6ccf3b2283b22162b04ad164076953d9c174e5f54156e96c55de2c0
+  metadata.gz: 45157585361c3843ca530c27e06ccf1880d59f61115cd9f8da1ecae34d2fc41e
+  data.tar.gz: 2342a753d73994c4a7c725ae18f7247bf7047e347b3c1cec51dfeb83d7ff7449
 SHA512:
-  metadata.gz: 706e175a11fc0bcb0d7162e97452d19bbc4a86155d6301fa98d320dd15a98ad52fcfb9dcde08b61caa602d75e25ad27e837cc9246f09b0506fe642878eb530cb
-  data.tar.gz: f8aa095bd04e2a05d464c72cf22a60eb19637d98342f146e0bffb51c8945314afc9e84bce9406d0286311d6228634f1092c85e480febdd43bd05cca5aeba6c1d
+  metadata.gz: 39030c4c9072761a3f658c7d0d8269eedbafd60971db39992fa8712352b01e9cc71ec1ed07b5e51b9544d7119fdaa0025df8c2e86b8f413f52c496bbffa76819
+  data.tar.gz: b586b21ff073186953fac8d5c8fa96e5c79150a355e14983188cc6ddca0e388b26efe4a49a95a07a56e2c58f250a3899c14a984e062223119de8e0e106ab8875

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 0.0.8 2026/04/15
+- `Rational#approx_reduction(true)` includes only better approximations.
+
+## 0.0.7 2026/04/15
+- Fix missing the alias of `Math.ln` from `Math.log`.
+- Refine `Float#to_r` and `Rational#approx_reduction`.
+
 ## 0.0.6 2026/04/13
 - Add `Rational#approx_reduction` and refine `Float#to_r` by using this method.
 

data/README.md

@@ -32,10 +32,21 @@ Returns `Rational` value of `self`.
 Returns exact `Rational` value of `self`, that may not be desirable for usual usage.
 For instance, (0.1).to_r_exact returns (3602879701896397/36028797018963968) while (0.1).to_r returns (1/10).
 
-### `Rational#approx_reduction(dig=8, depth=16, org=self)`
-Returns aprroximately same as `org` `Rational` value with smaller denominator.
-This method search for changing numerator and denominator of `self` by within `1<<dig`.
-`depth` is the maximum recursive depth of this method.
+### `Rational#approx_reduction(all=false)`
+Without the following conditions, this returns `Rational` approximation of `self` with smaller denominator, by using Stern-Brocot tree.
+If `all` is true, this returns an `Array` includes all the path to `self` of the Stern-Brocot tree.
+
+When `self==(0/1)` and `all` is false, this returns `self`.
+
+When `self==(0/1)` and `all` is true, this returns a pair of negative and positive `Rational` with least denominator which is converted to `0.0` by `Rational#to_f`. For IEEE 754 compliant environments, the value would be -/+ `Rational(1, (((1<<67)-0x4008)<<1008))`.
+
+When `self.denominator==1` and `all` is false, this returns a `Rational` value with least absolute numerator which is converted to `self.to_f` by `Rational#to_f`.
+
+When `self.denominator==1` and `all` is true, this returns a pair of `Rational`s with least and greatest numerator which are converted to `self.to_f` by `Rational#to_f`.
+
+When `self.numerator.abs==1` and `all` is false, this returns a `Rational` value with least denominator which is converted to `selft.to_f` by `Rational#to_f`.
+
+When `self.numerator.abs==1` and `all` is true, this returns a pair of `Rational`s with least and greatest denominator which are converted to `self.to_f` by `Rational#to_f`.
 
 ### `Integer#to_msm(fps=59.94)`
 Returns `"[minutes]:[seconds].[milliseconds]"` which corresponds to `self` frames.

data/lib/kgl/kmath.rb

@@ -1,84 +1,162 @@
+class << Math
+	alias ln log
+end
 module Math
 	alias ln log
 	module_function
 	def log(base, anti_logarithm=base.tap{base=nil})
 		if base.nil?
-			ln(angi_logarithm)
+			ln(anti_logarithm)
 		else
 			ln(anti_logarithm).quo(ln(base))
 		end
 	end
 	def lg(anti_logarithm)
-		log(2, anti_logarithm)
+		log(2.0, anti_logarithm)
 	end
 end
 
 class Rational
-	protected def kglsize
-		[self.numerator.abs, self.denominator].min
-	end
-	protected def kgldiff(other)
-		(self-other).abs
-	end
-	def approx_reduction(dig=8, depth=16, org=self)
-		return self if depth <= 0
-		self.to_f rescue return self
-		ret, app = self, self
-		if (1<<(dig*2)) < self.kglsize
-			1.upto(1<<dig) do |i|
-				[[0, i], [0, -i], [i, 0], [-i, 0]].each do |n, d|
-					q = Rational(numerator+n, denominator+d)
-					if q.kglsize < ret.kglsize
-						if q.kgldiff(org) <= ret.kgldiff(org)
-							ret = q 
-						elsif q.kglsize < app.kglsize
-							app = q
-						end
-					end
-				end
-				1.upto(i) do |j|
-					[[j, i], [j, -i], [-j, i], [-j, -i]].each do |a, b|
-						q = Rational(numerator+a, denominator+b)
-						if q.kglsize < ret.kglsize
-							if q.kgldiff(org) <= ret.kgldiff(org)
-								ret = q 
-							elsif q.kglsize < app.kglsize
-								app = q
-							end
-						end
-						q = Rational(numerator+b, denominator+a)
-						if q.kglsize < ret.kglsize
-							if q.kgldiff(org) <= ret.kgldiff(org)
-								ret = q 
-							elsif q.kglsize < app.kglsize
-								app = q
-							end
-						end
-					end
+	def approx_reduction(all=false)
+		if self.numerator == 0
+			return self unless all
+			d = 0
+			d += 1 while Rational(1, 1<<d).to_f != 0.0
+			n = 1<<d
+			(d-1).downto(0) do |i|
+				e = (1<<i)
+				n -= e if Rational(1, n-e).to_f == 0.0
+			end
+			return [Rational(-1, n), Rational(1, n)]
+		elsif self.denominator == 1
+			s = self < 0 ? -1 : 1
+			d, n = 0, self.numerator.abs
+			f = n.to_f
+			d += 1 while (n-(1<<d)).to_f == f
+			(d-1).downto(0) do |i|
+				e = (1<<i)
+				n -= e if (n-e).to_f == f
+			end
+			r = Rational(n*s, 1)
+			return r unless all
+			d, n = 0, self.numerator.abs
+			d += 1 while (n+(1<<d)).to_f == f
+			(d-1).downto(0) do |i|
+				e = (1<<i)
+				n += e if (n+e).to_f == f
+			end
+			if n == r.numerator.abs
+				return [r]
+			else
+				return [r, Rational(n*s, 1)]
+			end
+		elsif self.numerator.abs == 1
+			d, n = 0, self.denominator
+			f = self.to_f.abs
+			if f == 0.0
+				unless all
+					return Rational(0, 1).approx_reduction(true)[self.numerator<0 ? 0 : 1]
+				else
+					return Rational(0, 1).approx_reduction(true)
 				end
 			end
-		end
-		if ret.kglsize < self.kglsize
-			ret.approx_reduction(dig, depth-1, org)
+			d += 1 while Rational(1, n-(1<<d)).to_f == f
+			(d-1).downto(0) do |i|
+				e = (1<<i)
+				n -= e if Rational(1, n-e).to_f == f
+			end
+			r = Rational(self.numerator, n)
+			return r unless all
+			d, n = 0, self.denominator
+			d += 1 while Rational(1, n+(1<<d)).to_f == f
+			(d-1).downto(0) do |i|
+				e = (1<<i)
+				n += e if Rational(1, n+e).to_f == f
+			end
+			if n == r.denominator
+				return [r]
+			else
+				return [r, Rational(self.numerator, n)]
+			end
 		else
-			app.approx_reduction(dig, depth-1, org)
+			s = self < 0 ? -1 : 1
+			q = self.abs
+			if q.denominator < q.numerator
+				l = [q.numerator.div(q.denominator), 1]
+				h = [l[0]+1, 1]
+			else
+				h = [1, q.denominator.div(q.numerator)]
+				l = [1, h[1]+1]
+			end
+			res = [Rational(*l)]
+			r = Rational(*h)
+			foo, bar = (r-q).abs, (res[0]-q).abs
+			res = [r] if foo < bar || ( foo == bar && h.min < l.min )
+			i = 0
+			loop do
+				m = [l[0]+h[0], l[1]+h[1]]
+				r = Rational(*m)
+				if q.denominator <= r.denominator
+					return all ? res : res[-1]
+				elsif r < q
+					l = m
+				else
+					h = m
+				end
+				res << r*s if (r-q).abs < (res[-1]-q).abs
+			end
 		end
 	end
 end
 
 class Float
-	def to_r(th=8)
-		r = self.to_r_exact
-		q = r.approx_reduction
-		q.to_f == self ? q : r
+	if method_defined?(:to_r)
+		alias to_r_exact to_r
+	else
+		def to_r_exact
+			raise FloatDomainError, self.inspect unless self.finite?
+			if RADIX == 2
+				md = MANT_DIG
+			else
+				md = (MANT_DIG*Math.lg(RADIX)).floor
+			end
+			s, e = Math.frexp(self)
+			if e < md
+				Rational(Math.ldexp(s, md).to_i, 1<<(md-e))
+			else
+				Rational(self.to_i, 1)
+			end
+		end
 	end
-	def to_r_exact
-		raise FloatDomainError, self.inspect unless self.finite?
-		s, e = Math.frexp(self)
-		if e < MANT_DIG
-			Rational(Math.ldexp(s, MANT_DIG).to_i, 1<<(MANT_DIG-e))
+	def to_r
+		a = self.abs
+		q = a.to_r_exact
+		s = (self < 0.0) ? -1 : 1
+		if q.denominator < q.numerator
+			l = [q.numerator.div(q.denominator), 1]
+			r = Rational(*l)
+			return r*s if r.to_f == a
+			h = [l[0]+1, 1]
+			r = Rational(*h)
+			return r*s if r.to_f == a
 		else
-			Rational(self.to_i, 1)
+			h = [1, q.denominator.div(q.numerator)]
+			r = Rational(*h)
+			return r*s if r.to_f == a
+			l = [1, h[1]+1]
+			r = Rational(*l)
+			return r*s if r.to_f == a
+		end
+		loop do
+			m = [l[0]+h[0], l[1]+h[1]]
+			r = Rational(*m)
+			if r.to_f == a
+				return r*s
+			elsif r < q
+				l = m
+			else
+				h = m
+			end
 		end
 	end
 end

data/lib/kgl/version.rb

@@ -1,3 +1,3 @@
 module Kgl
-  VERSION = '0.0.6'
+  VERSION = '0.0.8'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kgl
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - KAZOON