hensel_code 0.2.1 → 0.4.0

data/lib/hensel_code/finite_gadic_expansion.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # truncated finite g-adic expansion hensel code class
+  class FiniteGadicExpansion < GAdicBase
+    def modululi
+      primes.map { |prime| prime**exponent }
+    end
+
+    def to_a
+      hensel_code.map(&:to_a)
+    end
+
+    def to_s
+      hensel_code.map(&:to_s).to_s
+    end
+
+    def inspect
+      "<HenselCode: #{self}>"
+    end
+
+    def inverse
+      new_hensel_code = hensel_code.map(&:inverse)
+      self.class.new primes, exponent, new_hensel_code
+    end
+
+    private
+
+    def evaluate(operation, other)
+      new_hensel_code = hensel_code.zip(other.hensel_code).map { |pair| pair[0].send(operation, pair[1]) }
+      self.class.new primes, exponent, new_hensel_code
+    end
+
+    def valid_number?(number)
+      if number.is_a?(Rational)
+        @rational = number
+      elsif number.is_a?(Array) && number.map(&:class).uniq == [HenselCode::FinitePadicExpansion]
+        @hensel_code = number
+        decode
+      else
+        message = "number must be a Rational or an\
+        Array of finite p-adic Hensel codes and it was a #{number.class}"
+        raise WrongHenselCodeInputType, message
+      end
+    end
+
+    def valid_hensel_code?(new_hensel_code)
+      condition = new_hensel_code.is_a?(Array) && new_hensel_code.map(&:class).uniq == [HenselCode::FPE]
+      message = "must be an array of finite p-adic Hensel codes"
+      raise WrongHenselCodeInputType, message unless condition
+    end
+
+    def encode
+      @g = primes.inject(:*)
+      @hensel_code = primes.map do |prime|
+        FinitePadicExpansion.new prime, exponent, rational
+      end
+    end
+
+    def decode
+      hs = hensel_code.map { |h| h.to_truncated.hensel_code }
+      h = TruncatedFinitePadicExpansion.new g, exponent, crt(modululi, hs)
+      @rational = h.to_r
+    end
+  end
+end

data/lib/hensel_code/finite_padic_expansion.rb

@@ -3,6 +3,8 @@
 module HenselCode
   # finite p-adic expansion hensel code class
   class FinitePadicExpansion < PAdicBase
+    attr_accessor :polynomial
+
     def modulus
       prime
     end
@@ -22,26 +24,25 @@ module HenselCode
     end
 
     def inspect
-      "[HenselCode: #{polynomial_form}, prime: #{prime}, exponent: #{exponent}, modulus: #{modulus}]"
+      "<HenselCode: #{polynomial_form}>"
     end
 
-    private
-
-    def evaluate(operation, other)
-      h_ = to_truncated.send(operation, other.to_truncated).hensel_code
-      new_hensel_code = (0..exponent - 1).map { |i| h_ / (prime**i) % prime }
+    def inverse
+      new_hensel_code = polynomial.inverse.coefficients
       self.class.new prime, exponent, new_hensel_code
     end
 
-    def polynomial_variable(index)
-      i = index > 1 ? 2 : index
-      ["", "p", "p^#{index}"][i]
-    end
+    private
 
     def polynomial_form
       to_s
     end
 
+    def evaluate(operation, other)
+      new_hensel_code = polynomial.send(operation, other.polynomial).coefficients
+      self.class.new prime, exponent, new_hensel_code
+    end
+
     def valid_number?(number)
       if number.is_a?(Rational)
         @rational = number
@@ -66,8 +67,8 @@ module HenselCode
     end
 
     def encode
-      h_ = TruncatedFinitePadicExpansion.new(prime, exponent, rational).hensel_code
-      @hensel_code = (0..exponent - 1).map { |i| h_ / (prime**i) % prime }
+      @hensel_code = rational_to_padic_digits
+      @polynomial = Polynomial.new prime, hensel_code
     end
 
     def decode
@@ -75,5 +76,31 @@ module HenselCode
       hensel_code.each_with_index { |d, i| number += d * (prime**i) }
       @rational = TruncatedFinitePadicExpansion.new(prime, exponent, number).to_r
     end
+
+    def rational_to_padic_digits
+      digits = [rational_to_integer(rational)]
+      alpha = rational - digits.last
+      (exponent - 1).times do
+        alpha = reduce_rational_in_terms_of_prime(alpha)
+        digits << rational_to_integer(alpha)
+        alpha -= digits.last
+      end
+      digits
+    end
+
+    def reduce_rational_in_terms_of_prime(alpha)
+      divisor_numerator = alpha.numerator.gcd(prime)
+      divisor_denominator = alpha.denominator.gcd(prime)
+      if divisor_numerator != 1
+        alpha /= divisor_numerator
+      elsif divisor_denominator != 1
+        alpha *= divisor_denominator
+      end
+      alpha
+    end
+
+    def rational_to_integer(rat)
+      (rat.numerator * mod_inverse(rat.denominator, prime)) % prime
+    end
   end
 end

data/lib/hensel_code/gadic_base.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # base hensel code class
+  class GAdicBase
+    include Tools
+    include GAdicVerifier
+
+    attr_accessor :primes, :exponent, :rational, :hensel_code, :g, :n
+    private :primes=, :exponent=, :rational=, :hensel_code=
+
+    def initialize(primes, exponent, number)
+      can_initilize?
+      @primes = primes
+      @exponent = exponent
+      @g = primes.inject(:*)
+      @n = Integer.sqrt(((g**exponent) - 1) / 2)
+      valid_number?(number)
+      encode
+      decode
+    end
+
+    def numerator
+      rational.numerator
+    end
+
+    def denominator
+      rational.denominator
+    end
+
+    def to_r
+      decode
+      rational
+    end
+
+    def +(other)
+      valid?(other)
+      evaluate("+", other)
+    end
+
+    def -(other)
+      valid?(other)
+      evaluate("-", other)
+    end
+
+    def *(other)
+      valid?(other)
+      evaluate("*", other)
+    end
+
+    def /(other)
+      valid?(other)
+      evaluate("/", other)
+    end
+
+    def replace_primes(new_primes)
+      replace_attribute("primes=", new_primes, 0)
+    end
+
+    def replace_exponent(new_exponent)
+      replace_attribute("exponent=", new_exponent, 0)
+    end
+
+    def replace_rational(new_rational)
+      replace_attribute("rational=", new_rational, 0)
+    end
+
+    def replace_hensel_code(new_hensel_code)
+      valid_hensel_code?(new_hensel_code)
+      replace_attribute("hensel_code=", new_hensel_code, 1)
+    end
+
+    private
+
+    def can_initilize?
+      message = "#{self.class} can only be inherited."
+      raise NonInitializableClass, message if instance_of?(HenselCode::GAdicBase)
+    end
+
+    def replace_attribute(attribute, new_value, order)
+      send(attribute, new_value)
+      order.zero? ? [encode, decode] : [decode, encode]
+      self
+    end
+  end
+end

data/lib/hensel_code/gadic_verifier.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # verifications pre-evaluation of hensel codes
+  module GAdicVerifier
+    def valid?(other)
+      incompatible_operand_type?(other)
+      different_primes_and_same_exponent?(other)
+      different_primes_and_different_exponent?(other)
+      same_primes_and_different_exponent?(other)
+    end
+
+    def incompatible_operand_type?(other)
+      message = "#{self} is a #{self.class} while #{other} is a #{other.class}"
+      raise IncompatibleOperandTypes, message unless instance_of?(other.class)
+    end
+
+    def different_primes_and_same_exponent?(other)
+      message = "#{self} has primes #{primes} while #{other} has prime #{other.primes}"
+      raise HenselCodesWithDifferentPrimes, message if primes != other.primes && exponent == other.exponent
+    end
+
+    def different_primes_and_different_exponent?(other)
+      message = <<~MSG
+        "#{self} has prime #{primes} and exponent #{exponent}
+        while #{other} has prime #{other.primes} and exponent #{other.exponent}
+      MSG
+      raise HenselCodesWithDifferentPrimesAndExponents, message if primes != other.primes && exponent != other.exponent
+    end
+
+    def same_primes_and_different_exponent?(other)
+      message = "#{self} has exponent #{exponent} while #{other} has exponent #{other.exponent}"
+      raise HenselCodesWithDifferentExponents, message if primes == other.primes && exponent != other.exponent
+    end
+  end
+end

data/lib/hensel_code/modular_arithmetic.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # modular arithmetic class
+  module ModularArithmetic
+    def cauchy_product(prime, coefficients1, coefficients2)
+      product = []
+      carry = 0
+      (0..coefficients1.size - 1).each do |i|
+        sum = 0
+        (0..i).each { |j| sum += (coefficients1[j] * coefficients2[i - j]) }
+        product << ((carry + sum) % prime)
+        carry = (carry + sum) / prime
+      end
+      product
+    end
+
+    def multiplication(prime, coefficients1, coefficients2)
+      partial_multiplications = []
+      coefficients2.each_with_index do |c1, i|
+        rows = multiplication_inner_loop(prime, coefficients1, coefficients2, c1, i)
+        partial_multiplications << rows
+        rows.append(*([0] * i))
+      end
+      sum_of_partial_multiplications(partial_multiplications)
+    end
+
+    private
+
+    def multiplication_inner_loop(prime, coefficients1, coefficients2, c1_, index)
+      rows = []
+      carry = 0
+      coefficients1.each_with_index do |c2, j|
+        rows << ((carry + (c1_ * c2)) % prime)
+        carry = (carry + (c1_ * c2)) / prime
+        (rows << carry).reverse!.insert(0, *([0] * (j - index))) if j == coefficients2.size - 1
+      end
+      rows
+    end
+
+    def sum_of_partial_multiplications(partial_multiplications)
+      carry = 0
+      sum = []
+      partial_multiplications.map(&:reverse).transpose.map do |x|
+        sum << ((carry + x.reduce(:+)) % prime)
+        carry = (carry + x.reduce(:+)) / prime
+      end
+      sum
+    end
+
+    def addition(prime, coefficients1, coefficients2)
+      carry = 0
+      result_coefficients = []
+      coefficients1.zip(coefficients2).each do |x|
+        result_coefficients << ((carry + x.reduce(:+)) % prime)
+        carry = (carry + x.reduce(:+)) / prime
+      end
+      result_coefficients
+    end
+
+    def subtraction(prime,  coefficients1, coefficients2)
+      addition(prime, coefficients1, negation(prime, coefficients2))
+    end
+
+    def negation(prime, coefficients)
+      leading_zeros = coefficients.take_while(&:zero?)
+      coefficients_without_leading_zeros = coefficients.drop_while(&:zero?)
+      new_coefficients = [(prime - coefficients_without_leading_zeros[0]) % prime]
+      new_coefficients += coefficients[leading_zeros.size + 1..].map do |c|
+        ((prime - 1) - c) % prime
+      end
+      leading_zeros + new_coefficients
+    end
+  end
+end

data/lib/hensel_code/padic_base.rb

@@ -10,11 +10,13 @@ module HenselCode
     private :prime=, :exponent=, :rational=, :hensel_code=
 
     def initialize(prime, exponent, number)
+      can_initilize?
       @prime = prime
       @exponent = exponent
       @n = Integer.sqrt(((prime**exponent) - 1) / 2)
       valid_number?(number)
       encode
+      decode
     end
 
     def numerator
@@ -69,6 +71,11 @@ module HenselCode
 
     private
 
+    def can_initilize?
+      message = "#{self.class} can only be inherited."
+      raise NonInitializableClass, message if instance_of?(HenselCode::PAdicBase)
+    end
+
     def replace_attribute(attribute, new_value, order)
       send(attribute, new_value)
       order.zero? ? [encode, decode] : [decode, encode]

data/lib/hensel_code/polynomial.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # polynomial class
+  class Polynomial
+    include HenselCode::Tools
+    include HenselCode::ModularArithmetic
+
+    attr_accessor :prime, :coefficients, :fixed_length
+
+    def initialize(prime, coefficients, fixed_length: true)
+      @prime = prime
+      @coefficients = coefficients
+      @fixed_length = fixed_length
+      valid_prime?
+      valid_coefficients?
+    end
+
+    def +(other)
+      valid_operands?(other)
+      new_coefficients = addition(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients
+    end
+
+    def -(other)
+      valid_operands?(other)
+      new_coefficients = subtraction(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients
+    end
+
+    def *(other)
+      valid_operands?(other)
+      new_coefficients = multiplication(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients[0..coefficients.size - 1]
+    end
+
+    def /(other)
+      valid_operands?(other)
+      new_coefficients = (self * other.inverse).coefficients
+      self.class.new prime, new_coefficients[0..coefficients.size - 1]
+    end
+
+    def inverse
+      x = generate_padic_x
+      two = generate_padic_constant_integer(2)
+      x = (two * x) - (self * x * x) while (x * self).coefficients != [1] + Array.new(coefficients.size - 1, 0)
+      x
+    end
+
+    def to_s
+      coefficients.map.with_index do |c, i|
+        "#{c}#{polynomial_variable(i)}"
+      end.join(" + ")
+    end
+
+    def inspect
+      "<Polynomial: #{polynomial_form}>"
+    end
+
+    def degree
+      coefficients.size - 1
+    end
+
+    private
+
+    def valid_prime?
+      raise ArgumentError, "prime can't be nil" if @prime.nil?
+      raise ArgumentError, "prime must be an integer" unless @prime.is_a?(Integer)
+    end
+
+    def valid_coefficients?
+      coefficients_condition = @coefficients.is_a?(Array) && @coefficients.map(&:class).uniq == [Integer]
+      raise ArgumentError, "coefficients can't be nil" if @coefficients.nil?
+      raise ArgumentError, "coefficients must be an array" unless @coefficients.is_a?(Array)
+      raise ArgumentError, "coefficients must be an array" unless coefficients_condition
+    end
+
+    def valid_operands?(other)
+      s1 = coefficients.size
+      s2 = other.coefficients.size
+      raise WrongHenselCodeInputType, "polynomials must have same degree" if s1 != s2
+      raise WrongHenselCodeInputType, "polynomials must have same prime" if prime != other.prime
+    end
+
+    def generate_padic_x
+      x_coefficients = [mod_inverse(coefficients[0], prime)] + Array.new(coefficients.size - 1) { rand(0..prime - 1) }
+      self.class.new prime, x_coefficients
+    end
+
+    def generate_padic_constant_integer(number)
+      self.class.new prime, [number] + Array.new(coefficients.size - 1, 0)
+    end
+
+    def mul(other)
+      new_coefficients = multiplication(prime, coefficients, other.coefficients)
+      self.class.new prime, new_coefficients
+    end
+
+    def polynomial_form
+      to_s
+    end
+  end
+end

data/lib/hensel_code/tools.rb

@@ -36,13 +36,13 @@ module HenselCode
       end
     end
 
-    def random_distinct_primes(quantity, bits)
-      primes = [random_prime(bits)]
-      while primes.size < quantity
-        prime = random_prime(bits)
-        primes << prime if prime != primes.last
+    def random_distinct_numbers(type, quantity, bits)
+      numbers = [send("random_#{type}", bits)]
+      while numbers.size < quantity
+        number = send("random_#{type}", bits)
+        numbers << number unless numbers.include?(number)
       end
-      primes
+      numbers
     end
 
     def eea_core(num1, num2, bound = 0)
@@ -77,5 +77,23 @@ module HenselCode
 
       y % mod
     end
+
+    def crt(moduli, remainders)
+      g = moduli.inject(:*)
+      result = 0
+      moduli.zip(remainders) do |modulus, remainder|
+        g_prime = g / modulus
+        g_prime_inverse = mod_inverse(g_prime, modulus)
+        result += ((g_prime * g_prime_inverse * remainder))
+      end
+      result % g
+    end
+
+    private
+
+    def polynomial_variable(index)
+      i = index > 1 ? 2 : index
+      ["", "p", "p^#{index}"][i]
+    end
   end
 end

data/lib/hensel_code/truncated_finite_gadic_expansion.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module HenselCode
+  # truncated finite g-adic expansion hensel code class
+  class TruncatedFiniteGadicExpansion < GAdicBase
+    def modululi
+      primes.map { |prime| prime**exponent }
+    end
+
+    def to_a
+      hensel_code.map(&:to_i)
+    end
+
+    def to_s
+      hensel_code.map(&:to_i).to_s
+    end
+
+    def inspect
+      "<HenselCode: #{to_a}>"
+    end
+
+    def inverse
+      new_hensel_code = hensel_code.map(&:inverse)
+      self.class.new primes, exponent, new_hensel_code
+    end
+
+    private
+
+    def evaluate(operation, other)
+      new_hensel_code = hensel_code.zip(other.hensel_code).map { |pair| pair[0].send(operation, pair[1]) }
+      self.class.new primes, exponent, new_hensel_code
+    end
+
+    def valid_number?(number)
+      if number.is_a?(Rational)
+        @rational = number
+      elsif number.is_a?(Array) && number.map(&:class).uniq == [HenselCode::TruncatedFinitePadicExpansion]
+        @hensel_code = number
+        decode
+      else
+        message = "number must be a Rational or an\
+        Array of truncated p-adic Hensel codes and it was a #{number.class}"
+        raise WrongHenselCodeInputType, message
+      end
+    end
+
+    def valid_hensel_code?(new_hensel_code)
+      condition = new_hensel_code.is_a?(Array) && new_hensel_code.map(&:class).uniq == [HenselCode::TFPE]
+      message = "must be an array of truncated p-adic Hensel codes"
+      raise WrongHenselCodeInputType, message unless condition
+    end
+
+    def encode
+      @g = primes.inject(:*)
+      @hensel_code = primes.map do |prime|
+        TruncatedFinitePadicExpansion.new prime, exponent, rational
+      end
+    end
+
+    def decode
+      h = TruncatedFinitePadicExpansion.new g, exponent, crt(modululi, hensel_code.map(&:to_i))
+      @rational = h.to_r
+    end
+  end
+end

data/lib/hensel_code/truncated_finite_padic_expansion.rb

@@ -16,7 +16,12 @@ module HenselCode
     end
 
     def inspect
-      "[HenselCode: #{hensel_code}, prime: #{prime}, exponent: #{exponent}, modulus: #{modulus}]"
+      "<HenselCode: #{hensel_code}>"
+    end
+
+    def inverse
+      new_hensel_code = mod_inverse(hensel_code, modulus)
+      self.class.new prime, exponent, new_hensel_code
     end
 
     private

data/lib/hensel_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HenselCode
-  VERSION = "0.2.1"
+  VERSION = "0.4.0"
 end

data/lib/hensel_code.rb

@@ -13,15 +13,23 @@ module HenselCode
   class HenselCodesWithDifferentPrimesAndExponents < StandardError; end
   class HenselCodesWithDifferentExponents < StandardError; end
   class IncompatibleOperandTypes < StandardError; end
+  class NonInitializableClass < StandardError; end
 
   autoload  :Tools, "hensel_code/tools"
   autoload  :PAdicBase, "hensel_code/padic_base"
+  autoload  :GAdicBase, "hensel_code/gadic_base"
+  autoload  :Polynomial, "hensel_code/polynomial"
   autoload  :PAdicVerifier, "hensel_code/padic_verifier"
+  autoload  :GAdicVerifier, "hensel_code/gadic_verifier"
+  autoload  :ModularArithmetic, "hensel_code/modular_arithmetic"
   autoload  :FinitePadicExpansion, "hensel_code/finite_padic_expansion"
+  autoload  :FiniteGadicExpansion, "hensel_code/finite_gadic_expansion"
   autoload  :TruncatedFinitePadicExpansion, "hensel_code/truncated_finite_padic_expansion"
+  autoload  :TruncatedFiniteGadicExpansion, "hensel_code/truncated_finite_gadic_expansion"
 
   # aliases for classes with long names
   TFPE = TruncatedFinitePadicExpansion
+  FPE = TruncatedFinitePadicExpansion
   HCWDPAE = HenselCodesWithDifferentPrimesAndExponents
   WHIT = WrongHenselCodeInputType
 end