abst 0.2.0

data/test/test_group.rb

@@ -0,0 +1,10 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'abst'
+
+class TC_Group < MiniTest::Unit::TestCase
+	def test_element_order
+		f_7 = Abst.residue_class_field(7 * Integer)
+		assert_equal(6, Abst.element_order(f_7.new(3), 6))
+	end
+end

data/test/test_integer.rb

@@ -0,0 +1,161 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'abst'
+
+class TC_Fundamental < MiniTest::Unit::TestCase
+	def test_to_fs
+		assert_equal('0', 0.to_fs)
+		assert_equal('1', 1.to_fs)
+		assert_equal('123 456 789', 123456789.to_fs)
+		assert_equal('1 234 567 890', 1234567890.to_fs)
+	end
+
+	def test_bit_size
+		assert_equal(0, 0.bit_size)
+		assert_equal(1, 1.bit_size)
+		assert_equal(2, 2.bit_size)
+		assert_equal(2, 3.bit_size)
+		assert_equal(3, 4.bit_size)
+		assert_equal(3, 5.bit_size)
+		assert_equal(10, 1023.bit_size)
+		assert_equal(11, 1024.bit_size)
+		assert_equal(11, 1025.bit_size)
+	end
+
+	def test_factorial
+		assert_equal(1, 0.factorial)
+		assert_equal(1, 1.factorial)
+		assert_equal(2, 2.factorial)
+		assert_equal(6, 3.factorial)
+		assert_equal(24, 4.factorial)
+		assert_equal(120, 5.factorial)
+		assert_equal(720, 6.factorial)
+	end
+
+	def test_pmod_factorial
+		assert_equal(1, 0.pmod_factorial(5))
+		assert_equal(1, 1.pmod_factorial(5))
+		assert_equal(0, 2.pmod_factorial(2))
+		assert_equal(1, 3.pmod_factorial(5))
+		assert_equal(7, 4.pmod_factorial(17))
+		assert_equal(27, 5.pmod_factorial(31))
+		assert_equal(0, 6.pmod_factorial(5))
+	end
+
+	def test_extended_pmod_factorial
+		assert_equal([1, 0], 0.extended_pmod_factorial(5))
+		assert_equal([1, 0], 1.extended_pmod_factorial(5))
+		assert_equal([1, 1], 2.extended_pmod_factorial(2))
+		assert_equal([2, 1], 3.extended_pmod_factorial(3))
+		assert_equal([7, 0], 4.extended_pmod_factorial(17))
+		assert_equal([1, 3], 5.extended_pmod_factorial(2))
+		assert_equal([4, 1], 6.extended_pmod_factorial(5))
+	end
+
+	def test_combination
+		assert_equal(1, 1.combination(1))
+		assert_equal(1, 1.combination(0))
+		assert_equal(45, 10.combination(2))
+		assert_equal(120, 10.combination(7))
+	end
+
+	def test_pmod_combination
+		assert_equal(1, 1.pmod_combination(1, 2))
+		assert_equal(1, 1.pmod_combination(0, 3))
+		assert_equal(0, 10.pmod_combination(2, 3))
+		assert_equal(3, 10.pmod_combination(7, 13))
+		assert_equal(0, (10 ** 18).pmod_combination(10 ** 9, 2437))
+		assert_equal(673, (10 ** 18).pmod_combination(10 ** 9, 3389))
+	end
+
+	def test_power_of?
+		assert_equal(true, 2.power_of?(2))
+		assert_equal(false, 3.power_of?(2))
+		assert_equal(true, 36.power_of?(6))
+		assert_equal(false, 100.power_of?(11))
+	end
+
+	def test_square?
+		assert_equal(1, 1.square?)
+		assert_equal(false, 2.square?)
+		assert_equal(false, 3.square?)
+		assert_equal(2, 4.square?)
+		assert_equal(false, 5.square?)
+		assert_equal(13, 169.square?)
+		assert_equal(false, 42342341.square?)
+
+		10.times do
+			n = rand(10 ** 10) + 1
+			square = n ** 2
+			assert_equal(n, square.square?)
+			assert_equal(false, (square + 1).square?)
+		end
+	end
+
+	def test_squarefree?
+		assert_equal(true, 1.squarefree?)
+		assert_equal(true, 2.squarefree?)
+		assert_equal(true, 3.squarefree?)
+		assert_equal(false, 4.squarefree?)
+		assert_equal(true, 5.squarefree?)
+		assert_equal(true, 6.squarefree?)
+		assert_equal(true, 7.squarefree?)
+		assert_equal(false, 8.squarefree?)
+		assert_equal(true, (7 * 13).squarefree?)
+		assert_equal(false, (5 * 13 * 13).squarefree?)
+	end
+
+	def test_triangle?
+		assert_equal(1, 1.triangle?)
+		assert_equal(false, 2.triangle?)
+		assert_equal(2, 3.triangle?)
+		assert_equal(false, 4.triangle?)
+		assert_equal(false, 5.triangle?)
+		assert_equal(3, 6.triangle?)
+		assert_equal(false, 7.triangle?)
+	end
+
+	def test_pentagonal?
+		assert_equal(1, 1.pentagonal?)
+		assert_equal(false, 2.pentagonal?)
+		assert_equal(false, 3.pentagonal?)
+		assert_equal(false, 4.pentagonal?)
+		assert_equal(2, 5.pentagonal?)
+		assert_equal(false, 6.pentagonal?)
+	end
+
+	def test_hexagonal?
+		assert_equal(1, 1.hexagonal?)
+		assert_equal(false, 2.hexagonal?)
+		assert_equal(false, 3.hexagonal?)
+		assert_equal(false, 4.hexagonal?)
+		assert_equal(false, 5.hexagonal?)
+		assert_equal(2, 6.hexagonal?)
+		assert_equal(false, 7.hexagonal?)
+	end
+
+	def test_heptagonal?
+		assert_equal(1, 1.heptagonal?)
+		assert_equal(false, 2.heptagonal?)
+		assert_equal(false, 3.heptagonal?)
+		assert_equal(false, 4.heptagonal?)
+		assert_equal(false, 5.heptagonal?)
+		assert_equal(false, 6.heptagonal?)
+		assert_equal(2, 7.heptagonal?)
+		assert_equal(false, 8.heptagonal?)
+		assert_equal(3, 18.heptagonal?)
+	end
+
+	def test_octagonal?
+		assert_equal(1, 1.octagonal?)
+		assert_equal(false, 2.octagonal?)
+		assert_equal(false, 3.octagonal?)
+		assert_equal(false, 4.octagonal?)
+		assert_equal(false, 5.octagonal?)
+		assert_equal(false, 6.octagonal?)
+		assert_equal(false, 7.octagonal?)
+		assert_equal(2, 8.octagonal?)
+		assert_equal(false, 9.octagonal?)
+		assert_equal(3, 21.octagonal?)
+	end
+end

data/test/test_matrix.rb

@@ -0,0 +1,54 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'abst'
+
+class TC_Matrix < MiniTest::Unit::TestCase
+	def test_Matrix
+		matrix = Abst::Matrix(Rational, 2, 3)
+		assert_equal("Rational", matrix.coef_class.name)
+		assert_equal(2, matrix.height)
+		assert_equal(3, matrix.width)
+
+		m = [[3, 5, 1], [9, 2, 3]]
+		assert_equal(m, Abst::Matrix(Rational, m).to_a)
+	end
+
+	def test_each
+		matrix = Abst::Matrix(Rational, 2, 2)
+		m = matrix.new([[3, 5], [1, 2]])
+		assert_equal([3, 5, 1, 2], m.each.to_a)
+	end
+
+	def test_add
+		matrix = Abst::Matrix(Rational, 2, 3)
+		m1 = matrix.new([[2, 3, 2], [4, 5, -7]])
+		m2 = matrix.new([[3, 1, 4], [2, -3, 1]])
+
+		assert_equal([[5, 4, 6], [6, 2, -6]], (m1 + m2).to_a)
+	end
+
+	def test_sub
+		matrix = Abst::Matrix(Rational, 2, 3)
+		m1 = matrix.new([[2, 3, 2], [4, 5, -7]])
+		m2 = matrix.new([[3, 1, 4], [2, -3, 1]])
+
+		assert_equal([[-1, 2, -2], [2, 8, -8]], (m1 - m2).to_a)
+	end
+
+	def test_solve
+		assert_equal([2].to_v, [[2, 4]].to_m.solve)
+		assert_equal([-5.5, 6.0].to_v, [[2, 3, 7], [4, 5, 8]].to_m.solve)
+		assert_equal([-22, 20].to_v, [[4, 5, 12], [2, 3, 16]].to_m.solve)
+		assert_equal([-2, 2, 1].to_v, [[1, 1, 1, 1], [1, 2, 3, 5], [2, 4, 8, 12]].to_m.solve)
+		assert_equal(nil, [[1, 2, 3, 12], [4, 5, 6, 13], [7, 8, 9, 14]].to_m.solve)
+	end
+end
+
+class TC_SquareMatrix < MiniTest::Unit::TestCase
+	def test_trace
+		matrix = Abst::Matrix(Rational, 2, 2)
+		m = matrix.new([[2, 3], [4, 5]])
+
+		assert_equal(7, m.trace)
+	end
+end

data/test/test_polynomial.rb

@@ -0,0 +1,107 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'abst'
+
+class TC_Polynomial < MiniTest::Unit::TestCase
+	def test_Polynomial
+		polynomial = Abst::Polynomial(Rational)
+		assert_equal("Rational", polynomial.coef_class.name)
+
+		poly = polynomial.new([1, Rational(2, 7), 3])
+		assert_equal([1, Rational(2, 7), 3], poly.to_a)
+
+		poly = Abst::Polynomial(Rational, [3, 5])
+		assert_equal([3, 5], poly.to_a)
+	end
+
+	def test_zero
+		polynomial = Abst::Polynomial(Rational)
+		assert_equal([0], polynomial.zero.to_a)
+	end
+
+	def test_one
+		polynomial = Abst::Polynomial(Rational)
+		assert_equal(polynomial.new([1]), polynomial.one)
+	end
+
+	def test_add
+		polynomial = Abst::Polynomial(Integer)
+		poly1 = polynomial.new([2, 3, 4])
+		poly2 = polynomial.new([-3, 12, -4])
+		poly3 = polynomial.new([-3, 12])
+		assert_equal([-1, 15], (poly1 + poly2).to_a)
+		assert_equal([-1, 15, 4], (poly1 + poly3).to_a)
+		assert_equal([4, 3, 4], (poly1 + 2).to_a)
+	end
+
+	def test_sub
+		polynomial = Abst::Polynomial(Integer)
+
+		poly1 = polynomial.new([2, 3, 4])
+		poly2 = polynomial.new([-3, 12, 4])
+		poly3 = polynomial.new([-3, 12])
+		assert_equal([5, -9], (poly1 - poly2).to_a)
+		assert_equal([5, -9, 4], (poly1 - poly3).to_a)
+		assert_equal([0, 3, 4], (poly1 - 2).to_a)
+	end
+
+	def test_mul
+		polynomial = Abst::Polynomial(Integer)
+		poly1 = polynomial.new([2, 3, 4])
+		poly2 = polynomial.new([-3, 12, -4])
+		expect = polynomial.new([-6, 15, 16, 36, -16])
+
+		assert_equal(expect, (poly1 * poly2))
+	end
+
+	def test_divmod
+		polynomial = Abst::Polynomial(Integer)
+
+		poly1 = polynomial.new([1, 2, 3])
+		poly2 = polynomial.new([1])
+		q, r = poly1.divmod(poly2)
+		assert_equal(poly1, q)
+		assert_equal(polynomial.zero, r)
+
+		poly3 = polynomial.new([4, 5, 0, 1])
+		poly4 = polynomial.new([3, 3, 1])
+		q, r = poly3.divmod(poly4)
+		assert_equal(polynomial.new([-3, 1]), q)
+		assert_equal(polynomial.new([13, 11]), r)
+	end
+
+	def test_eq
+		polynomial = Abst::Polynomial(Integer)
+		poly1 = polynomial.new([2, 3, 4])
+		poly2 = polynomial.new([2, 3, 4])
+		poly3 = polynomial.new([-3, 12, -4])
+
+		assert_equal(true, poly1 == poly2)
+		assert_equal(false, poly1 == poly3)
+	end
+
+	def test_degree
+		polynomial = Abst::Polynomial(Integer)
+		poly = polynomial.new([2, 3, 4, 0])
+		assert_equal(2, poly.degree)
+	end
+
+	def test_lc
+		polynomial = Abst::Polynomial(Integer)
+		poly = polynomial.new([2, 3, 4])
+		assert_equal(4, poly.lc)
+	end
+
+	def test_eval
+		polynomial = Abst::Polynomial(Integer)
+		poly = polynomial.new([2, -3, 4])
+		assert_equal(3, poly.eval(1))
+		assert_equal(12, poly.eval(2))
+	end
+
+	def test_to_a
+		polynomial = Abst::Polynomial(Integer)
+		poly = polynomial.new([2, -3, 4])
+		assert_equal([2, -3, 4], poly.to_a)
+	end
+end

data/test/test_prime.rb

@@ -0,0 +1,153 @@
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'abst'
+
+class TC_Prime < MiniTest::Unit::TestCase
+	def test_primes_list
+		list = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+		assert_equal(list, Abst.primes_list[0...10])
+	end
+
+	def test_pseudoprime_test
+		assert_equal(true, Abst.pseudoprime_test(3, 2))
+		assert_equal(true, Abst.pseudoprime_test(5, 3))
+		assert_equal(true, Abst.pseudoprime_test(7, 4))
+		assert_equal(false, Abst.pseudoprime_test(4, 3))
+		assert_equal(false, Abst.pseudoprime_test(15, 8))
+	end
+
+	def test_strong_pseudoprime_test
+		assert_equal(true, Abst.strong_pseudoprime_test(3, 2))
+		assert_equal(true, Abst.strong_pseudoprime_test(5, 3))
+		assert_equal(true, Abst.strong_pseudoprime_test(7, 4))
+		assert_equal(false, Abst.strong_pseudoprime_test(12, 5))
+	end
+
+	def test_miller_rabin
+		assert_equal(true, Abst.miller_rabin(3))
+		assert_equal(false, Abst.miller_rabin(4))
+		assert_equal(true, Abst.miller_rabin(5))
+		assert_equal(false, Abst.miller_rabin(6))
+		assert_equal(true, Abst.miller_rabin(11))
+		assert_equal(false, Abst.miller_rabin(169))
+	end
+
+	def test_n_minus_1
+		assert_equal(true, Abst.n_minus_1(3))
+		assert_equal(false, Abst.n_minus_1(4))
+		assert_equal(true, Abst.n_minus_1(5))
+		assert_equal(false, Abst.n_minus_1(6))
+		assert_equal(true, Abst.n_minus_1(7))
+		assert_equal(false, Abst.n_minus_1(561))
+		assert_equal(true, Abst.n_minus_1(507526619771207))
+	end
+
+	def test_prime?
+		assert_equal(false, Abst.prime?(1))
+		assert_equal(true, Abst.prime?(2))
+		assert_equal(true, Abst.prime?(3))
+		assert_equal(false, Abst.prime?(4))
+		assert_equal(true, Abst.prime?(5))
+		assert_equal(false, Abst.prime?(6))
+		assert_equal(true, Abst.prime?(7))
+		assert_equal(false, Abst.prime?(8))
+		assert_equal(false, Abst.prime?(9))
+		assert_equal(false, Abst.prime?(10))
+		assert_equal(true, Abst.prime?(11))
+		assert_equal(false, Abst.prime?(12))
+		assert_equal(true, Abst.prime?(13))
+		assert_equal(true, Abst.prime?(17))
+		assert_equal(false, Abst.prime?(1_373_653))
+	end
+
+	def test_trial_division
+		assert_equal([[[2, 1]], 1], Abst.trial_division(2))
+		assert_equal([[[3, 1]], 1], Abst.trial_division(3))
+		assert_equal([[[2, 2]], 1], Abst.trial_division(4))
+		assert_equal([[[5, 1]], 1], Abst.trial_division(5))
+		assert_equal([[[2, 1], [3, 1]], 1], Abst.trial_division(6))
+		assert_equal([[[11, 1]], 1], Abst.trial_division(11))
+		assert_equal([[[13, 2]], 1], Abst.trial_division(169))
+		assert_equal([[[2, 2], [231053, 1], [415039, 1]], 708806692316951],
+			Abst.trial_division(4 * 231053 * 415039 * 70_880_669_231_6951, 500_000))
+	end
+
+	def test_differences_of_squares
+		assert_equal([985109, 2993579], Abst.differences_of_squares(2949001615111))
+		assert_equal([6576439, 8192167], Abst.differences_of_squares(53875286553313))
+		assert_equal([4121987, 9553081], Abst.differences_of_squares(39377675691947))
+	end
+
+	def test_pollard_rho
+		assert_equal(155240783, Abst.pollard_rho(3876131431000528283))
+		assert_equal(2252849497, Abst.pollard_rho(5409492426475365797, 1, 2, 100_000))
+		assert_equal(1264621003, Abst.pollard_rho(11781814522941624827, 1, 2, 100_000))
+	end
+
+	def test_p_minus_1
+		assert_equal(3, Abst.p_minus_1(6, 10_000, 2))
+		assert_equal(3292218043, Abst.p_minus_1(9530738504299322287, 10_000, 2))
+		assert_equal(6042787811, Abst.p_minus_1(23916353875143281737, 10_000, 2))
+		assert_equal(8228369521, Abst.p_minus_1(24559500716705748943, 10_000, 2))
+		assert_equal(7046628167, Abst.p_minus_1(43381522922949440477, 10_000, 2))
+		assert_equal(9571252001, Abst.p_minus_1(79670656009259581439, 10_000, 2))
+		assert_equal(6135173419, Abst.p_minus_1(19256936255213267029, 10_000, 2))
+	end
+
+	def test_factorize
+		assert_equal([[-1, 1]], Abst.factorize(-1))
+		assert_equal([[0, 1]], Abst.factorize(0))
+		assert_equal([[1, 1]], Abst.factorize(1))
+		assert_equal([[2, 1]], Abst.factorize(2))
+		assert_equal([[3, 1]], Abst.factorize(3))
+		assert_equal([[2, 2]], Abst.factorize(4))
+		assert_equal([[5, 1]], Abst.factorize(5))
+		assert_equal([[2, 2], [3, 1]], Abst.factorize(12))
+		assert_equal([[3, 4]], Abst.factorize(81))
+		assert_equal([[2, 10]], Abst.factorize(1024))
+		assert_equal([[-1, 1], [3, 1], [5, 3]], Abst.factorize(-375))
+		assert_equal([[3, 1], [224743, 2]], Abst.factorize(151528248147))
+		assert_equal([[1658414587, 1], [5856287651, 1]], Abst.factorize(5856287651 * 1658414587))
+	end
+
+	def test_eratosthenes_sieve
+		assert_equal([2, 3, 5, 7], Abst.eratosthenes_sieve(10).to_a)
+		assert_equal([2, 3, 5, 7, 11], Abst.eratosthenes_sieve(11).to_a)
+		assert_equal([2, 3, 5, 7, 11], Abst.eratosthenes_sieve(12).to_a)
+		assert_equal([2, 3, 5, 7, 11, 13, 17, 19], Abst.eratosthenes_sieve(20).to_a)
+	end
+
+	def test_next_prime
+		assert_equal(2, Abst.next_prime(-5))
+		assert_equal(2, Abst.next_prime(0))
+		assert_equal(2, Abst.next_prime(1))
+		assert_equal(3, Abst.next_prime(2))
+		assert_equal(5, Abst.next_prime(3))
+		assert_equal(5, Abst.next_prime(4))
+		assert_equal(7, Abst.next_prime(5))
+		assert_equal(7, Abst.next_prime(6))
+		assert_equal(11, Abst.next_prime(7))
+		assert_equal(29, Abst.next_prime(23))
+		assert_equal(101, Abst.next_prime(100))
+		assert_equal(599993, Abst.next_prime(599983))
+		assert_equal(900001, Abst.next_prime(899981))
+	end
+
+	def test_each_prime
+		assert_equal([2, 3, 5, 7], (0..10).each_prime.to_a)
+		assert_equal([11, 13, 17, 19], (11..20).each_prime.to_a)
+		assert_equal([23, 29, 31, 37], (21...41).each_prime.to_a)
+		assert_equal([23, 29, 31, 37, 41], (21..41).each_prime.to_a)
+	end
+
+	def test_phi
+		assert_equal(1, Abst.phi(1))
+		assert_equal(1, Abst.phi(2))
+		assert_equal(2, Abst.phi(3))
+		assert_equal(2, Abst.phi(4))
+		assert_equal(4, Abst.phi(5))
+		assert_equal(2, Abst.phi(6))
+		assert_equal(6, Abst.phi(7))
+		assert_equal(4, Abst.phi(8))
+	end
+end