kgl 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a7096ca78114cdf718f0c28ebea651c3883beb97e661fac637797ed97320713
-  data.tar.gz: 913f01ff7a69aa1b7ce27ae4e1bcc6670b30aabd9711b78fa61b2fd66d4317e7
+  metadata.gz: 65df30d3f96fe5550514270600cc924f65c474889636576cf9be72c6a00879e6
+  data.tar.gz: b44e9faebbfa2a4460eb73473bce524c436cb51b632b3840374844790acf96c3
 SHA512:
-  metadata.gz: 5ed96a95a203a6509d2c2a198b39c441e7704fee12e20eb9e7686b423f5824a8738cfefdc73e37acc88b42e81f297eb93151cf0f9cc6c198d513d7cb54ca8533
-  data.tar.gz: 6d88af36b4a74a21f91711bc3a1ff1ec11b09cc1f59ce6c649bf293032bc7b1073caabefa8f7ecf31ccc71c74b5529b825fff3519c758584ab320803743d58df
+  metadata.gz: 7681c208a10a33e12f18f4950071390f06b39f9acae485f7f3959f31b32f6902941bb5ea563dc5a0300ac49898e144da7286e1e2761cd0cf8065e896d214eae2
+  data.tar.gz: 27861552dd8c9d13cecaac96b29bd788a62e88c6910d7bbdff0efe2ae33e7c939c8d2bb50dc36d8473c932d4fc452f41c09a41a57c3fb1b14272bee0c65a9ce6

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 0.0.7
+- 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.
+
 ## 0.0.5 2026/04/12
 - `Float#to_r` and `Float#to_r_exact` raise `FloatDomainError` when `self` is not finite.
 

data/README.md

@@ -32,6 +32,22 @@ 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(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.
 The submilliseconds will be rounded. `fps` is frames per second.

data/lib/kgl/kmath.rb

@@ -1,46 +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 Float
-	def to_r
-		unless self.finite?
-			raise FloatDomainError
-		end
-		str = self.to_s
-		(decimal, power) = str.split(/e/)
-		(integer, decimal) = decimal.split(/\./)
-		length = decimal.length
-		numerator = integer.to_i*10**length+decimal.to_i
-		denominator = 10**length
-		power = power.to_i
-		if power > 0
-			numerator *= 10**power
+class Rational
+	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
+			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
-			denominator *= 10**(-power)
+			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
+			end
 		end
-		return Rational(numerator, denominator)
 	end
-	def to_r_exact
-		unless self.finite?
-			raise FloatDomainError
+end
+
+class Float
+	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
-		s, e = Math.frexp(self)
-		if e < 53
-			Rational(Math.ldexp(s, 53).to_i, 1<<(53-e))
+	end
+	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.5'
+  VERSION = '0.0.7'
 end

metadata

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