abst 0.2.0

data/lib/include/rational.rb

@@ -0,0 +1,155 @@
+class Rational
+	def self.one
+		return Rational(1, 1)
+	end
+
+	def self.zero
+		return Rational(0, 1)
+	end
+
+	def inverse
+		return 1 / self
+	end
+
+	# to repeating decimal string
+	def to_rds(base = 10)
+		raise ArgumentError, "invalid radix #{base}" if base < 2 or 36 < base
+
+		# initialize
+		quotient = []
+
+		n = numerator.to_s(base).split('').map(&:to_i)
+		exp = 0
+		while 0 == n.last
+			n.pop
+			exp += 1
+		end
+		d = denominator
+		loop do
+			q, r = d.divmod(base)
+			break unless 0 == r
+			d = q
+			exp -= 1
+		end
+		t = n[0]
+
+		# division loop
+		i = 1
+		loop do
+			q, r = t.divmod(d)
+			t = r * base + n[i].to_i
+
+			quotient.push([q, nil])
+
+			unless n[i]
+				if 0 == t
+					quotient.last[1] = 0
+					break
+				end
+				break if quotient.map(&:last).include?(t)
+				quotient.last[1] = t
+			end
+
+			i += 1
+		end
+
+		# format
+		rslt = "0."
+
+		zero_count = 0
+		while 0 == quotient[0][0]
+			zero_count += 1
+			if t == quotient.shift[1]
+				rslt += '('
+
+				# rotate 0
+				while 0 == quotient[0][0]
+					quotient.push(quotient.shift)
+					zero_count += 1
+				end
+				break
+			end
+		end
+		exp += n.size - zero_count
+
+		convert = "0123456789abcdefghijklmnopqrstuvwxyz"
+		if 0 == quotient.last[1]
+			rslt += quotient.map{|q| convert[q[0]]}.inject(&:+)
+		else
+			quotient.each do |q|
+				rslt += convert[q[0]]
+				rslt += '(' if t == q[1]
+			end
+			rslt +=  ")"
+		end
+		rslt +=  "e" + exp.to_s unless 0 == exp
+
+		return rslt
+	end
+
+	# to decimal string
+	def to_ds(length = 64, base = 10)
+		raise ArgumentError, "invalid radix #{base}" if base < 2 or 36 < base
+
+		# initialize
+		quotient = []
+
+		n = numerator.to_s(base).split('').map(&:to_i)
+		exp = 0
+		while 0 == n.last
+			n.pop
+			exp += 1
+		end
+		d = denominator
+		loop do
+			q, r = d.divmod(base)
+			break unless 0 == r
+			d = q
+			exp -= 1
+		end
+		t = n[0]
+
+		# division loop
+		i = 1
+		s = nil
+		loop do
+			q, r = t.divmod(d)
+			t = r * base + n[i].to_i
+
+			s = i - 1 if nil == s and q != 0
+			quotient.push([q, nil])
+
+			unless n[i]
+				if 0 == t
+					quotient.last[1] = 0
+					break
+				end
+				break if s and i - s == length
+				quotient.last[1] = t
+			end
+
+			i += 1
+		end
+
+		# format
+		zero_count = 0
+		while 0 == quotient[0][0]
+			zero_count += 1
+			if t == quotient.shift[1]
+				# rotate 0
+				while 0 == quotient[0][0]
+					quotient.push(quotient.shift)
+					zero_count += 1
+				end
+				break
+			end
+		end
+		exp += n.size - zero_count
+
+		convert = "0123456789abcdefghijklmnopqrstuvwxyz"
+		rslt = "0." + quotient.map{|q| convert[q[0]]}.inject(&:+)
+		rslt +=  "e" + exp.to_s unless 0 == exp
+
+		return rslt
+	end
+end

data/lib/include/residue.rb

@@ -0,0 +1,27 @@
+module Abst
+	module_function
+
+	def residue_class(ideal)
+		if prime?(ideal.n)
+			return residue_class_field(ideal)
+		else
+			return residue_class_ring(ideal)
+		end
+	end
+
+	def residue_class_ring(ideal)
+		residue_class = Class.new(IntegerResidueRing) do
+			@mod = ideal.n
+		end
+
+		return residue_class
+	end
+
+	def residue_class_field(maximal_ideal)
+		residue_class = Class.new(IntegerResidueField) do
+			@mod = maximal_ideal.n
+		end
+
+		return residue_class
+	end
+end

data/lib/include/ring.rb

@@ -0,0 +1,21 @@
+module Abst
+	module Ring
+		def self.included(base)
+			base.class_eval do
+				include Abst::Group
+			end
+		end
+
+		def /(other)
+			return self.divmod(other)[0]
+		end
+
+		def %(other)
+			return self.divmod(other)[1]
+		end
+
+		def **(e)
+			return Abst.power(self, e)
+		end
+	end
+end

data/lib/include/sequence.rb

@@ -0,0 +1,54 @@
+module Abst
+	module_function
+
+	$fibonacci = {0 => 0, 1 => 1}
+
+	# Param::  non-negative integer n
+	# Return:: the n-th Fibonacci number
+	# effect $fibonacci[n] = fibonacci(n)
+	def fibonacci(n)
+		return $fibonacci[n] if $fibonacci.include?(n)
+
+		m = n >> 1
+		if n.even?
+			f1 = fibonacci(m - 1)
+			f2 = fibonacci(m)
+			$fibonacci[n] = (f1 + f1 + f2) * f2
+		else
+			f1 = fibonacci(m)
+			f2 = fibonacci(m + 1)
+			$fibonacci[n] = f1 ** 2 + f2 ** 2
+		end
+
+		return $fibonacci[n]
+	end
+
+	# Triangle numbers are generated by the formula, T_n = n * (n + 1) / 2.
+	# The first ten triangle numbers are:
+	#     1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+	def triangle(n)
+		return n * (n + 1) >> 1
+	end
+
+	# Pentagonal numbers are generated by the formula, P_n = n * (3 * n - 1) / 2.
+	# The first ten pentagonal numbers are:
+	#     1, 5, 12, 22, 35, 51, 70, 92, 117, 145, ...
+	def pentagonal(n)
+		return n * (3 * n - 1) >> 1
+	end
+
+	# Hexagonal numbers are generated by the formula, H_n = n * (2 * n - 1)
+	# The first ten hexagonal numbers are:
+	#     1, 6, 15, 28, 45, 66, 91, 120, 153, 190, ...
+	def hexagonal(n)
+		return n * ((n << 1) - 1)
+	end
+
+	def heptagonal(n)
+		return n * (5 * n - 3) >> 1
+	end
+
+	def octagonal(n)
+		return n * (3 * n - 2)
+	end
+end

data/lib/include/set.rb

@@ -0,0 +1,67 @@
+class Set
+	include Enumerable
+
+	def initialize(ary = [])
+		@set = ary.uniq
+	end
+
+	def add(*items)
+		items.each do |i|
+			@set.push(i) unless @set.include?(i)
+		end
+		return self
+	end
+
+	def ==(other)
+		return false unless self.size == other.size
+		@set.each do |i|
+			return false unless other.include?(i)
+		end
+
+		return true
+	end
+
+	def each(&block)
+		@set.each(&block)
+	end
+
+	def size
+		@set.size
+	end
+
+	def dup
+		self.class.new(@set.dup)
+	end
+
+	def include?(a)
+		@set.include?(a)
+	end
+
+	def inspect
+		str = @set.inspect[1..-2]
+		return "{" + str + "}"
+	end
+
+	def to_a
+		return @set
+	end
+end
+
+class SortableSet < Set
+	def initialize(ary = [], &compare)
+		@set = ary.uniq.sort(&compare)
+		@compare = compare
+	end
+
+	def add(*items)
+		items.each do |i|
+			j = Bisect.bisect_left(@set, i, &@compare)
+			@set.insert(j, i) unless @set[j] == i
+		end
+		return self
+	end
+
+	def dup
+		self.class.new(@set.dup, &@compare)
+	end
+end

data/lib/include/vector.rb

@@ -0,0 +1,90 @@
+module Abst
+	module_function
+
+	class Vector
+		class << self
+			attr_reader :coef_class, :size
+
+			def to_s
+				return "#{size} length #{self.coef_class} Vector"
+			end
+
+			def inspect
+				return to_s
+			end
+		end
+
+		attr_reader :coef
+		protected :coef
+
+		def initialize(coef)
+			raise VectorSizeError unless coef.size == self.class.size
+			@coef = coef.to_a
+		end
+
+		def +(other)
+			raise VectorSizeError unless self.size == other.size
+			return self.class.new(self.coef.zip(other.coef).map{|a, b| a + b})
+		end
+
+		def -(other)
+			raise VectorSizeError unless self.size == other.size
+			return self.class.new(self.coef.zip(other.coef).map{|a, b| a - b})
+		end
+
+		def ==(other)
+			return @coef == other.to_a
+		end
+
+		def size
+			return self.class.size
+		end
+
+		def each
+			return Enumerator.new(self) unless block_given?
+
+			@coef.each do |i|
+				yield i
+			end
+		end
+
+		def squared_length
+			return self.coef.map{|i| i ** 2}.inject(&:+)
+		end
+
+		def [](index)
+			return @coef[index]
+		end
+
+		def to_a
+			return @coef.dup
+		end
+
+		def to_s
+			return @coef.to_s
+		end
+
+		def inspect
+			return "#{self.class}\n#{self}"
+		end
+	end
+
+	def create_vector_space(coef_class, size)
+		if size.kind_of?(Array)
+			elems = size
+			size = size.size
+		end
+
+		vector = Class.new(Vector) do
+			@coef_class = coef_class
+			@size = size
+		end
+
+		return vector.new(elems) if elems
+		return vector
+	end
+	alias Vector create_vector_space
+	module_function :Vector
+
+	class VectorSizeError < Exception; end
+end

data/test/test_all.rb

@@ -0,0 +1,15 @@
+require_relative 'test_array'
+require_relative 'test_bisect'
+require_relative 'test_combination'
+require_relative 'test_float'
+require_relative 'test_fundamental'
+require_relative 'test_group'
+require_relative 'test_integer'
+require_relative 'test_matrix'
+require_relative 'test_polynomial'
+require_relative 'test_prime'
+require_relative 'test_prime_mpqs'
+require_relative 'test_rational'
+require_relative 'test_sequence'
+require_relative 'test_set'
+require_relative 'test_vector'

data/test/test_array.rb

@@ -0,0 +1,10 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'abst'
+
+class TC_Array < MiniTest::Unit::TestCase
+	def test_each_coefficient
+		assert_equal([[0, 0], [0, 1], [1, 0], [1, 1]].sort,
+			[1, 1].each_coefficient.to_a.sort)
+	end
+end