class Junction
  attr_accessor :value, :coelements
  attr_reader :type
  ANY = "|";ALL = "&";ONE = "@";NON = "~";NIL = "?"
  def initialize(num_of_values,typeof,array=nil)
    if block_given?
      index = 0;@value = Array.new(num_of_values){|value|
          yield value, index;index+=1}
    elsif array;@value = array
    else;@value = Array.new(num_of_values)
    end
    @coelements = @value.size.to_i
    @type = ((typeof==ANY or typeof==ALL)?((typeof==ANY)?ANY: ALL):(NIL))
    @type = ((typeof==ONE or typeof==NON)?((typeof==ONE)?ONE: NON):(@type))
    return self
  end
  def any(num_of_values,array=nil)
    a = Junction.new(num_of_values,Junction::ANY,array)
    if block_given?
      index = 0;a.value = Array.new(num_of_values){|value|
          yield value, index;index+=1}
    elsif array;a.value = array
    else;a.value = Array.new(num_of_values)
    end
    a.coelements = a.value.size.to_i
    return a
  end
  def all(num_of_values,array=nil)
    a = Junction.new(num_of_values,Junction::ALL,array)
    if block_given?
      index = 0;a.value = Array.new(num_of_values){|value|
          yield value, index;index+=1}
    elsif array;a.value = array
    else;a.value = Array.new(num_of_values)
    end
    a.coelements = a.value.size.to_i
    return a
  end
  def one(num_of_values,array=nil)
    a = Junction.new(num_of_values,Junction::ONE,array)
    if block_given?
      index = 0;a.value = Array.new(num_of_values){|value|
          yield value, index;index+=1}
    elsif array;a.value = array
    else;a.value = Array.new(num_of_values)
    end
    a.coelements = a.value.size.to_i
    return a
  end
  def non(num_of_values,array=nil)
    a = Junction.new(num_of_values,Junction::NON,array)
    if block_given?
      index = 0;a.value = Array.new(num_of_values){|value|
          yield value, index;index+=1}
    elsif array;a.value = array
    else;a.value = Array.new(num_of_values)
    end
    a.coelements = a.value.size.to_i
    return a
  end
  def forall
    if block_given?
      index = 0;while index < coelements
        yield @value.at(index), index;index+=1
      end
    else;raise "No block given to \'forall\' method"
    end
  end
  def ==(value)
    case @type
    when ANY
      return @value.include?(value)
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index==value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index==value)?1:0)
      }
      return occurances==1
    when NON
      return (@value.include?(value))?false:true
    when NIL;return nil
    end
  end
  def !=(value)
    case @type
    when ANY
      return @value.include?(value)?false:true
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index!=value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index!=value)?1:0)
      }
      return occurances==1
    when NON
      return (@value.include?(value))
    when NIL;return nil
    end
  end
  def <(value)
    case @type
    when ANY
      return (@value.include?(value))?(@value.max < value):(nil)
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index < value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index < value)?1:0)
      }
      return occurances==1
    when NON
      return (@value.include?(value))?((@value.max < value)?false:true):(nil)
    when NIL;return nil
    end
  end
  def >(value)
    case @type
    when ANY
      return (@value.include?(value))?(@value.max > value):(nil)
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index > value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index > value)?1:0)
      }
      return occurances==1
    when NON
      return (@value.include?(value))?((@value.max > value)?false:true):(nil)
    when NIL;return nil
    end
  end
  def <=(value)
    case @type
    when ANY
      return (@value.include?(value))?(@value.max <= value):(nil)
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index <= value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index <= value)?1:0)
      }
      return occurances==1
    when NON
      return (@value.include?(value))?((@value.max <= value)?false:true):(nil)
    when NIL;return nil
    end
  end
  def >=(value)
    case @type
    when ANY
      return (@value.include?(value))?(@value.max >= value):(nil)
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index >= value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index >= value)?1:0)
        return occurances==1
      }
    when NON
      return (@value.include?(value))?((@value.max >= value)?false:true):(nil)
    when NIL;return nil
    end
  end
  def ===(value)
    case @type
    when ANY
      return (@value.include?(value) and @value.at(@value.index(value))===value)
    when ALL
      occurances=1;@value.each {|index|
        occurances+=((index===value)?1:0)
      }
      return occurances==@coelements
    when ONE
      occurances=0;@value.each {|index|
        occurances+=((index===value)?1:0)
      }
      return occurances==1
    when NON
      return (@value.include?(value) and
          @value.at(@value.index(value))===value)?false:true
    when NIL;return nil
    end
  end
  def to_a#override
    return @value.to_a
  end
  def to_s#override
    character=NIL;case @type
    when ANY
      character=ANY
    when ALL
      character=ALL
    when ONE
      character=ONE
    when NON
      character=NON
    end
    return @value.to_s.gsub(", ",character)
  end
  def to_i
    @value.each {|i|(i = (i.to_i)) rescue i = 0}.to_a;return self
  end
  def to_f
    @value.each {|i|(i = (i.to_f)) rescue i = 0.0}.to_a;return self
  end
  def <<(value)
    @value.push(value);return self
  end
  def push_to_last!(value)
    @value.push(value);return self
  end
  def pop_last!
    return @value.pop
  end
  def pop_last_array!
    @value.pop;return self
  end
  def type_change(new_type)
    case new_type
    when ANY
      @type=ANY
    when ALL
      @type=ALL
    when ONE
      @type=ONE
    when NON
      @type=NON
    else
      @type=NIL
    end
  end
  def elements?
    @coelements.to_i
  end
  def clean!
    @value.uniq!;return self
  end
  def pretty_puts #not needed, but cool for easy reading :3
    self.forall {|i,j|puts "#{(j+1).to_s}" <<
        format_number_th(j) << " possible value is #{i.to_s}" }
  end
  private#helpers
  def format_number_th(j)#helper for pretty_puts
    if [10,11,12].include?(j%100);return "th"
    else;return (["st","nd","rd","th"].at((j%10>=4)?3:j%10)).to_s
    end
  end
end