abst_int 0.0.3

data/lib/abst_int/calculus_model/nfa.rb

@@ -0,0 +1,81 @@
+require "set"
+require "abst_int/calculus_model/dfa"
+
+module AbstInt::CalculusModel
+  class Nfa
+    def initialize
+      @states = Set.new
+      @initial_states = Set.new
+      @final_states = Set.new
+      @inputs = Set.new
+      @transition = {}
+    end
+
+    def add_initial state
+      @states << state
+      @initial_states << state
+    end
+
+    def add_final state
+      @states << state
+      @final_states << state
+    end
+
+    # [state] 1,2,3
+    # [input] 'a', 'b', 'c'
+    def add_trans state1, input, state2
+      @states << state1 << state2
+      @inputs << input
+      @transition[state1] ||= {}
+      @transition[state1][input] ||= Set.new
+      @transition[state1][input] << state2
+    end
+
+    def exists_initial?
+      not @initial_states.empty?
+    end
+
+    def to_dfa
+      dfa = AbstInt::CalculusModel::Dfa.new
+      dfa.set_initial @initial_states
+      dfa = generate_dfa dfa, @initial_states, Set.new
+      dfa.each_states do |states|
+        dfa.add_final states unless (states & @final_states).empty?
+      end
+      return dfa
+    end
+
+    def to_s
+      puts "[states]"
+      @states.each {|state| puts "#{state.is_a?(Array) ? state.map(&:to_s) : state}, " }
+      puts "[initial_states]"
+      @initial_states.each {|state| puts "#{state.is_a?(Array) ? state.map(&:to_s) : state}, " }
+      puts "[final_states]"
+      @final_states.each {|state| puts "#{state.is_a?(Array) ? state.map(&:to_s) : state}, " }
+      puts "[inputs]"
+      @inputs.each {|input| puts "#{input}, " }
+      puts "[transition]"
+      @transition.each do |state1, value|
+        value.each do |input, value|
+          value.each do |state2|
+            puts "#{state1.is_a?(Array) ? state1.map(&:to_s) : state1}, #{input}, #{state2.is_a?(Array) ? state2.map(&:to_s) : state2}"
+          end if value
+        end if value
+      end
+    end
+
+    private
+    def generate_dfa dfa, states, state_setset
+      return dfa if state_setset.include? states
+      old_dfa = dfa.dup
+      @inputs.each do |input|
+        next_states = states.inject(Set.new) do |result, state|
+          @transition.try(:[], state).try(:[], input) ? result + (@transition[state][input]) : result
+        end
+        dfa.add_trans states, input, next_states
+        dfa = generate_dfa dfa, next_states, (state_setset << states)
+      end
+      return dfa
+    end
+  end
+end

data/lib/abst_int/collection.rb

@@ -0,0 +1,32 @@
+class AbstInt::Collection < BasicObject
+  class NilClass
+  end
+
+  def initialize args
+    @objects = args
+  end
+
+  def == *args
+    self.method_missing :==, *args
+  end
+
+  def != *args
+    self.method_missing :"!=", *args
+  end
+
+  def equal? *args
+    self.method_missing :equal?, *args
+  end
+
+  def method_missing method_name, *args
+    result = ::AbstInt::Collection::NilClass.new
+    @objects.each do |object|
+      if result.is_a? ::AbstInt::Collection::NilClass
+        result = object.send(method_name, *args)
+      else
+        raise ::AbstInt::MultiResultError, "There are more results than one." unless result == object.send(method_name, *args)
+      end
+    end
+    return result
+  end
+end

data/lib/abst_int/integer.rb

@@ -0,0 +1,35 @@
+require "abst_int"
+
+class AbstInt::Integer
+  def initialize abst_int
+    @abst_int = abst_int
+  end
+
+  def + abst_int_or_int
+    @abst_int + abst_int_or_int
+  end
+
+  def - abst_int_or_int
+    @abst_int - abst_int_or_int
+  end
+
+  def * abst_int_or_int
+    @abst_int * abst_int_or_int
+  end
+
+  def / abst_int_or_int
+    @abst_int / abst_int_or_int
+  end
+
+  def % num
+    @abst_int % num
+  end
+
+  def to_s
+    @abst_int.to_s
+  end
+
+  def _terms
+    @abst_int.terms
+  end
+end

data/lib/abst_int/or_set.rb

@@ -0,0 +1,105 @@
+require "abst_int/set"
+require "abst_int/calculus_model/nfa"
+require "abst_int/collection"
+
+class AbstInt::OrSet
+  def initialize coefficient = nil, be_variable = false
+    @elements = []
+    if coefficient.is_a? Fixnum
+      self << (AbstInt::Set.new coefficient, be_variable)
+    end
+  end
+
+  def + orset
+    return self if orset.nil?
+    new_orset = AbstInt::OrSet.new
+    orset.each do |set1|
+      self.each do |set2|
+        new_orset << (set1 + set2)
+      end
+    end
+    return new_orset
+  end
+
+  def - orset
+    self + orset * AbstInt::OrSet.new(-1)
+  end
+
+  def * orset
+    new_orset = AbstInt::OrSet.new
+    orset.each do |set1|
+      self.each do |set2|
+        new_orset << (set1 * set2)
+      end
+    end
+    return new_orset
+  end
+
+  def % num
+    current_mod = []
+    self.each do |set|
+      mod = set % num
+      current_mod << mod
+    end
+    return AbstInt::Collection.new(current_mod)
+  end
+
+  def | orset
+    return self if orset.is_a? NilClass
+    cloned_self = self.dup
+    orset.each do |set|
+      cloned_self << set
+    end
+    return cloned_self
+  end
+
+  def & orset
+    left_dfa = (self.to_nfa.to_dfa)
+    right_dfa = (orset.to_nfa.to_dfa)
+    result = left_dfa & right_dfa
+    result = result.to_orset
+    return result
+  end
+
+  def not
+    return self.to_nfa.to_dfa.not.to_orset
+  end
+
+  def star
+    new_orset = AbstInt::OrSet.new
+    self.each do |set|
+      new_orset << set.star
+    end
+    return new_orset
+  end
+
+  def to_s
+    @elements.map{|element| element.to_s}.join("|")
+  end
+
+  protected
+  def to_nfa
+    nfa = AbstInt::CalculusModel::Nfa.new
+    self.each do |set|
+      nfa = set.generate_nfa nfa
+    end
+    return nfa
+  end
+
+  def each &block
+    @elements.each(&block)
+  end
+
+  def << set
+    expanded = false
+    @elements.each { |self_set|
+      next if expanded
+      expanded_set = self_set.expand(set) || set.expand(self_set)
+      next if expanded_set.nil?
+      expanded = true
+      @elements = @elements - [self_set]
+      self << expanded_set
+    }
+    @elements << set unless expanded
+  end
+end

data/lib/abst_int/set.rb

@@ -0,0 +1,136 @@
+require "abst_int/term"
+require "abst_int/calculus_model/nfa"
+
+class AbstInt::Set
+  def initialize coefficient = nil, be_variable = false
+    @elements = []
+    if coefficient.is_a? Fixnum
+      self  << (AbstInt::Term.new coefficient, be_variable)
+    end
+  end
+
+  def + set
+    cloned_self = self.dup
+    set.each do |term|
+      cloned_self << term
+    end
+    return cloned_self
+  end
+
+  def - set
+    self + set * AbstInt::Set.new(-1)
+  end
+
+  def * set
+    result = AbstInt::Set.new
+    cloned_self = self.dup
+    cloned_self.each do |self_term|
+      set.each do |term|
+        result << (self_term * term)
+      end
+    end
+    return result
+  end
+
+  def % num
+    @elements.inject(0){|result, term| [result, term % num].max }
+  end
+
+  def star
+    result = AbstInt::Set.new
+    self.each do |term|
+      result << term.star
+    end
+    return result
+  end
+
+  def to_s
+    @elements.map{|element| element.to_s}.join("+")
+  end
+
+  def generate_nfa nfa
+    self.each do |term|
+      # 各termごとの設定
+      nfa = term.generate_nfa nfa, self
+    end
+    unless nfa.exists_initial?
+      nfa.add_initial self
+      nfa.add_final self
+    end
+    return nfa
+  end
+
+  def include? set
+    # setの変数に0を代入して計算
+    set_offset = set.calc 0
+    # その値がselfに含まれているか確認
+    input_string = set_offset < 0 ? "b" * (- set_offset) : "a" * set_offset
+    return false unless self.to_nfa.to_dfa.accept? input_string
+    # 含まれているならば、変数項の係数の包含関係をチェック
+    set.each do |term|
+      next unless term.variable_exists?
+      include_check = false
+      self.each do |self_term|
+        next unless self_term.variable_exists?
+        include_check = include_check || self_term.include?(term)
+      end
+      return false unless include_check
+    end
+    return true
+  end
+
+  def expand set
+    return self if self.include? set
+    return nil unless self.check_lank == 1 && set.check_lank == 0
+    set_offset = set.calc 0
+    if self.calc(-1) == set_offset
+      new_set = AbstInt::Set.new
+      new_set << AbstInt::Term.new(set_offset)
+      self.each do |term|
+        new_set << term if term.variable_exists?
+      end
+      return new_set
+    else
+      return nil
+    end
+  end
+
+  def check_lank
+    lank = 0
+    self.each do |term|
+      lank += 1 if term.variable_exists?
+    end
+    return lank
+  end
+
+  protected
+  def each &block
+    @elements.each(&block)
+  end
+
+  def << term
+    new_elements = []
+    added_flag = false
+    @elements.each do |element|
+      if (element =~ term) && (not added_flag)
+        new_elements << (element + term)
+        added_flag = true
+      else
+        new_elements << element
+      end
+    end
+    new_elements << term unless added_flag
+    @elements = new_elements
+    return nil
+  end
+
+  def to_nfa
+    nfa = AbstInt::CalculusModel::Nfa.new
+    nfa = self.generate_nfa nfa
+    return nfa
+  end
+
+  def calc num
+    @elements.inject(0){|sum, x| sum + (x.calc num)}
+  end
+end

data/lib/abst_int/term.rb

@@ -0,0 +1,125 @@
+require "abst_int/variable"
+
+class AbstInt::Term
+
+  def initialize coefficient = nil, be_variable = false
+    @coefficient = coefficient || 1
+    @variables = []
+    self << AbstInt::Variable.new if be_variable
+  end
+
+  def << variable
+    @variables << variable
+    @variables.sort!
+  end
+
+  # like terms check
+  def =~ term
+    return false unless @variables.length == term.variables.length
+    @variables.each_with_index do |variable, i|
+      return false unless variable.id == term.variables[i].id
+    end
+    return true
+  end
+
+  # collect like terms
+  def + term
+    raise "this is not like terms." unless self =~ term
+    cloned_term = self.clone
+    cloned_term.coefficient += term.coefficient
+    return cloned_term
+  end
+
+  def * abst_int_or_term
+    cloned_term = self.clone
+    term = abst_int_or_term
+    cloned_term.coefficient *= term.coefficient
+    term.variables.each do |variable|
+      cloned_term << variable
+    end
+    return cloned_term
+  end
+
+  def % num
+    if @variables.empty?
+      return (@coefficient % num)
+    else
+      raise AbstInt::MultiResultError, "There are more results than one." if @coefficient % num != 0
+      return 0
+    end
+  end
+
+  def star
+    cloned_term = AbstInt::Term.new
+    cloned_term.coefficient = @coefficient
+    cloned_term.variables = @variables
+    cloned_term.variables = cloned_term.variables + [AbstInt::Variable.new] if @variables.empty? && @coefficient != 0
+    return cloned_term
+  end
+
+  def generate_nfa nfa, set
+    if @variables.empty?
+      if @coefficient == 0
+      elsif @coefficient < 0
+        nfa.add_initial [self, @coefficient]
+        nfa.add_final set
+        state_proc = proc { |x| (x == 0) ? set : [self, x] }
+        (@coefficient...0).each do |i|
+          nfa.add_trans state_proc.call(i), 'b', state_proc.call(i+1)
+        end
+      else
+        nfa.add_initial set
+        nfa.add_final [self, @coefficient]
+        state_proc = proc { |x| (x == 0) ? set : [self, x] }
+        (0...@coefficient).each do |i|
+          nfa.add_trans state_proc.call(i), 'a', state_proc.call(i+1)
+        end
+      end
+    else
+      state_proc = proc { |x| (x == 0 || x == @coefficient) ? set : [self, x] }
+      alphabet = @coefficient < 0 ? 'b' : 'a'
+      unsigned_coefficient = @coefficient < 0 ? -@coefficient : @coefficient
+      @coefficient.times do |i|
+        nfa.add_trans state_proc.call(i), alphabet, state_proc.call(i+1)
+      end
+    end
+    return nfa
+  end
+
+  # for debug
+  def to_s
+    "#{@coefficient}#{@variables.map{|var| var.to_s}.join}"
+  end
+
+  def calc num
+    return @variables.empty? ?  @coefficient : @coefficient * num
+  end
+
+  def variable_exists?
+    return not(@variables.empty?)
+  end
+
+  # 一旦、変数ありterm同士の包含比較
+  def include? term
+    return false unless self.variable_exists? && term.variable_exists?
+    return true if term.coefficient % self.coefficient == 0
+    return false
+  end
+
+  protected
+  def coefficient
+    @coefficient
+  end
+
+  def coefficient= coefficient
+    @coefficient = coefficient
+  end
+
+  def variables
+    @variables
+  end
+
+  def variables= variables
+    @variables = variables
+  end
+end