facets 0.9.0 → 1.0.0

data/lib/mega/fixnum_const.rb

@@ -1,62 +0,0 @@
-#--
-# Fixnum Constants
-#
-# Copyright (c) 2005 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-#
-# ==========================================================================
-# Revision History ::
-# --------------------------------------------------------------------------
-#  05.07.05  trans   * Placed in Calibre
-# ==========================================================================
-#++
-
-#:title: Fixnum Constants
-#
-# Constants providing the numerical limitations of Fixnum class.
-#
-# == Synopsis
-#
-#   require 'mega/fixnum-constants'
-#
-#   puts Fixnum::MAX  #=>
-#
-class Fixnum
-  N_BYTES = [42].pack('i').size
-  N_BITS = N_BYTES * 8
-  MAX = 2 ** (N_BITS - 2) - 1
-  MIN = -MAX - 1
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-# TODO
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_FixnumConst < Test::Unit::TestCase
-
-    def test_01
-    end
-
-  end
-
-=end

data/lib/mega/floatstring.rb

@@ -1,179 +0,0 @@
-#--
-# FloatString
-#
-# Copyright (c) 2004,2005 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-#
-# ==========================================================================
-# Revision History ::
-# --------------------------------------------------------------------------
-#  04.11.01   Trans    * Complete first usable verion (still needs TLC)
-# ==========================================================================
-#++
-
-#:title: FloatString
-#
-# FloatString allows unlimited string insertion between string segments.
-#
-# == Usage
-#
-#   TODO: Comming soon.....
-#
-# == Notes
-#
-# Although usable, it is still a very new idea, and therefore
-# has a much greater potential for change. If you decide it is useful
-# to you, please contribute to its improvement. Thanks.
-#
-# == Author(s)
-#
-# * Thomas Sawyer
-#
-
-class FloatString
-
-  def initialize( str )
-    @str = str
-    @float = {}
-    i = 0
-    while i < @str.length
-      @float[i.to_f] = @str[i,1]
-      i += 1
-    end 
-  end
-
-  def undo
-    initialize( @str )
-  end
-
-  def re_enumerate
-    initialize( to_s )
-  end
-  alias_method( :renumerate, :re_enumerate )
-
-  def to_s
-    @float.to_a.sort_by{ |k,v| k }.collect{ |k,v| v }.join('')
-  end
-
-  def to_str
-    @float.to_a.sort_by{ |k,v| k }.collect{ |k,v| v }.join('')
-  end
-
-  # these should probably check the decimal and start there
-  # rather then startint at 0.5
-  
-  def inner_insert(s, i)
-    n = 0.5; i = i.to_f - n
-    while @float.has_key?(i)
-      n = n/2
-      i += n
-    end
-    @float[i] = s
-  end
-  
-  def outer_insert(s, i)
-    n = 0.5; i = i.to_f - 0.5
-    while @float.has_key?(i)
-      n = n/2
-      i -= n
-    end
-    @float[i] = s
-  end
-  
-  def inner_append(s, i)
-    n = 0.5; i = i.to_f + 0.5
-    while @float.has_key?(i)
-      n = n/2
-      i -= n
-    end
-    @float[i] = s
-  end
-  
-  def outer_append(s, i)
-    n = 0.5; i = i.to_f + 0.5
-    while @float.has_key?(i)
-      n = n/2
-      i += n
-    end
-    @float[i] = s
-  end
-
-  # an inner and outer wrap method would be nice
-    
-  def [](arg)
-    if arg.kind_of?(Range)
-      #r = Range.new(arg.first.to_f, arg.last.to_f, arg.exclude_end?)
-      a = @float.to_a.sort_by{ |k,v| k }
-      s = a.index(a.find{ |e| e[0] == arg.first.to_f})
-      f = a.index(a.find{ |e| e[0] == arg.last.to_f})
-      a = arg.exclude_end? ? a[s...f] : a[s..f]
-      a.collect{ |k,v| v }.join('')
-    else
-      @float[arg.to_f]
-    end
-  end
-  
-  def []=(arg,v)
-    @float[arg.to_f] = v
-  end
-  
-  def fill(val, rng=0..-1)
-    a = @float.to_a.sort_by{ |k,v| k }
-    s = a.index( a.find{ |e| e[0] == rng.first.to_f } )
-    f = a.index( a.find{ |e| e[0] == rng.last.to_f } )
-    x = (rng.exclude_end? ? a[s...f] : a[s..f])
-    x.each{ |k,v| @float[k] = val.to_s }
-    self.to_s
-  end
-  
-  def empty(rng)
-    fill('', rng)
-  end
-
-  def blank(rng)
-    fill(' ', rng)
-  end
-  
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit' 
-
-  class TC_FloatString < Test::Unit::TestCase
-
-    def test_inner_inset
-      fs = FloatString.new( "Hello World!" )
-      fs.inner_insert("XXX", 4)
-      assert_equal("HellXXXo World!", fs.to_s)
-      fs.inner_insert("YYY", 4)
-      assert_equal("HellXXXYYYo World!", fs.to_s)
-    end
-
-    def test_fill
-      fs = FloatString.new( "Hello World!" )
-      fs.inner_insert("XXX", 4)
-      assert_equal("HeNNNN World!", fs.fill("N", 2..4))
-    end
-
-  end
-
-=end

data/lib/mega/functor.rb

@@ -1,98 +0,0 @@
-#--
-# Functor
-# Copyright (c) 2004,2005 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-# ==========================================================================
-#  Revision History
-# ==========================================================================
-#  05-09-22  trans
-#    Made a subclass of BasicObject.
-#
-#  05-01-10  trans
-#    Ported to Mega Modules.
-# ==========================================================================
-#++
-
-require 'mega/basicobject'
-
-#:title: Functor
-#
-# By definition a Functor is simply a first class method, but these are common
-# in the form of Method and Proc. So here a Functor is a bit more specialized
-# as a 1st class _metafunction_. Essentally, a Functor can vary its behavior
-# accorrding to the operation applied to it.
-#
-# == Synopsis
-#
-#   require 'mega/functor'
-#
-#   f = Functor.new { |op, x| x.send(op, x) }
-#   f + 1  #=> 2
-#   f + 2  #=> 4
-#   f + 3  #=> 6
-#   f * 1  #=> 1
-#   f * 2  #=> 2
-#   f * 3  #=> 9
-#
-# == Author(s)
-#
-# * Thomas Sawyer
-#
-
-class Functor < BasicObject
-  def initialize(*obj, &func)
-    @obj = obj
-    @func = func
-  end
-  def method_missing(op, *args)
-    if @obj.empty?
-      @func.call(op, *args)
-    else
-      @func.call(op, *(@obj + args))
-    end
-  end
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TC_Functor < Test::Unit::TestCase
-
-    def test_function
-      f = Functor.new { |op, x| x.send(op, x) }
-      assert_equal( 2, f + 1 ) #=> 2
-      assert_equal( 4, f + 2 ) #=> 4
-      assert_equal( 6, f + 3 ) #=> 6
-      assert_equal( 1, f * 1 ) #=> 1
-      assert_equal( 4, f * 2 ) #=> 4
-      assert_equal( 9, f * 3 ) #=> 9
-    end
-
-    def test_decoration
-      f = Functor.new("A") { |op, a, x| x.send(op, a + x) }
-      assert_equal( 'BAB', f + 'B' )
-      assert_equal( 'CAC', f + 'C' )
-      assert_equal( 'DAD', f + 'D' )
-    end
-
-  end
-
-=end

data/lib/mega/harray.rb

@@ -1,817 +0,0 @@
-#--
-# HArray
-#
-# Copyright (c) 2004,2005 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-#
-# ==========================================================================
-# Revision History ::
-# --------------------------------------------------------------------------
-#  04.09    Trans    * 99% Compatible with Array
-# ==========================================================================
-#++
-
-#:title: HArray
-#
-# HArray is an implemenation of the Array class using only Hashes.
-# Regular Arrays are never used except once to delegate the #pack method,
-# and for *args parameters (since there is no way around those is some cases).
-# HArray is for all practical purposes 100% compatible with Array.
-#
-# HArray is slower then the built in Array class, but not as slow
-# as one might expect, since a Hash in general is faster than an Array.
-# It might be interesting to see how this would perform if it were 
-# written in c. Not all that useful, but an interesting example.
-#
-# == AUTHOR(s)
-#
-# * Thamas Sawyer
-#
-
-class HArray < Hash
-
-  def HArray.[](*args)
-    nha = HArray.new
-    args.each { |a| nha.set(nha.length,a) }
-    nha
-  end
-
-  def HArray.new_h(hsh)
-    nha=HArray.new
-    nha.replace(hsh)
-    #nha.reindex!
-  end
-
-  def initialize(i=0,e=nil)
-    if i > 0
-      i.times { self.set(self.length,e) }
-    end
-  end
-
-  def &(ha)
-    nha=HArray.new
-    (0..self.length-1).each do |i|
-      if ha.has_value?(self.fetch(i)) and !nha.has_value?(self.fetch(i))
-        nha.set(nha.length,self.fetch(i))
-      end
-    end
-    nha
-  end
-
-  def *(j)
-    if j.kind_of?(String)
-      return self.join(j)
-    else
-      nha = HArray.new
-      j.times { (0...self.length).each { |i| nha.set(nha.length,self.fetch(i)) } }
-      return nha
-    end
-  end
-
-  def +(ha)
-    nha = self.dup
-    (0..ha.length-1).each { |i| nha.set(nha.length,ha.fetch(i)) }
-    nha
-  end
-
-  def -(ha)
-    nha = HArray.new
-    self.each { |v| nha << v if !ha.has_value?(v) }
-    #ha.each { |v| nha << i if !self.include?(v) }
-    nha
-  end
-
-  def <<(e)
-    self.set(self.length,e)
-    self
-  end
-
-  def <=>(ha)
-    (0..self.length-1).each do |i|
-      ieq = (self.fetch(i) <=> ha.fetch(i))
-      return ieq if ieq != 0
-    end
-    self.length <=> ha.length
-  end
-
-  def ===(ha)
-    self.==(ha)
-  end
-
-  alias_method :get, :[]
-  private :get
-
-  def [](i,l=nil)
-    if l
-      i = i...i+l
-    elsif ! i.kind_of?(Range)
-      return self.at(i)
-    end
-    nha = HArray.new
-    i.each { |j| nha.set(nha.length,get(j)) if has_key?(j) }
-    nha
-  end
-
-  alias set []=
-  def []=(i,b,c=nil)
-    if c
-      rng = (Integer(i)..Integer(i+b))
-      b = c
-    elsif i.kind_of? Range
-      rng = i
-    else
-      self.set(Integer(i),b)
-      return b
-    end
-    if b == nil
-      rng.each { |i| qdelete(i) }
-      self.reindex!
-    elsif b.kind_of?(Array) or b.kind_of?(HArray)
-      j = 0
-      rng.each { |i| self[i] = b[j]; j+=1 }
-    else
-      rng.each { |i| qdelete(i) }
-      self[rng.fist] = b
-      self.reindex!
-    end
-  end
-
-  def |(ha)
-    nha = self.dup
-    ha.each { |v| nha << v if !nha.has_value?(v) }
-    nha
-  end
-
-  def assoc(k)
-    (0...self.length).each { |i| return self.fetch(i) if self.fetch(i)[0] == k }
-    return nil
-  end
-
-  def at(i)
-    i = self.length + i if i <= -1
-    get(i)
-    #return nil if i < 0 or i >= self.length
-    #return self.fetch(i)
-  end
-
-  # clear okay
-
-  def collect
-    nha = HArray.new
-    (0...self.length).each { |i| nha << yield(self.fetch(i)) }
-    nha
-  end
-
-  def collect!
-    nha = HArray.new
-    (0...self.length).each { |i| nha << yield(self.fetch(i)) }
-    self.replace(nha)
-  end
-
-  def compact
-    nha, j = HArray.new, 0
-    (0..self.length-1).each do |i|
-      if self.fetch(i) != nil
-        nha.set(j,self.fetch(i))
-        j+=1
-      end
-    end
-    nha
-  end
-
-  def compact!
-    if self.has_value?(nil)
-      nha, j = HArray.new, 0
-      (0..self.length-1).each do |i|
-        if self.fetch(i) != nil
-          nha.set(j,self.fetch(i))
-          j+=1
-        end
-      end
-      return self.replace(nha)
-    else
-      return nil
-    end
-  end
-
-  def concat(ha)
-    (0...ha.length).each { |i| self.set(self.length,ha.fetch(i)) }
-    self
-  end
-
-  def count(e=nil)
-    if block_given?
-      cnt = 0
-      (0...self.length).each { |i| cnt += 1 if yield(self.fetch(i)) }
-      return cnt
-    else
-      cnt = 0
-      (0...self.length).each { |i| cnt += 1 if self.fetch(i) == e }
-      return cnt
-    end
-  end
-
-  alias qdelete delete
-  private :qdelete
-
-  def delete(e)
-    if has_value?(e)
-      qdelete_if { |i,v| v == e }
-      reindex!
-      return e
-    else
-      return yield if block_given?
-      return nil
-    end
-  end
-
-  def delete_at(i)
-    if self.has_key?(i)
-      e = self.fetch(i)
-      qdelete(i)
-      reindex!
-      return e
-    else
-      return nil
-    end
-  end
-
-  alias qdelete_if delete_if
-  private :qdelete_if
-
-  def delete_if
-    qdelete_if { |i,v| yield(v) }
-    reindex!
-  end
-
-  def each
-    (0...self.length).each { |i| yield(self.fetch(i)) }
-  end
-
-  def each_index
-    (0...self.length).each { |i| yield(i) }
-  end
-
-  # empty? okay as is
-
-  def eql?(ha)
-    return false if self.length != ha.length
-    return true if (0...self.length).all? { |i| self.fetch(i).eql?(ha.fetch(i)) }
-    return false
-  end
-
-  def fill(f,s=nil,l=nil)
-    if s.kind_of?(Range)
-      r = s
-    else
-      s = 0 if !s
-      l = self.length - s if !l
-      r = s...(s+l)
-    end
-    r.each{ |i| self.set(i,f) }
-    self
-  end
-
-  def first
-    return nil if self.empty?
-    self.fetch(0)
-  end
-
-  def flatten
-    nha = HArray.new
-    (0...self.length).each do |i|
-      sfi = self.fetch(i)
-      if sfi.kind_of?(HArray) or sfi.kind_of?(Array)
-        nha.concat(sfi.flatten)
-      else
-        nha.set(nha.length,sfi)
-      end
-    end
-    nha
-  end
-
-  def flatten!
-    return nil if !self.any? { |e| e.kind_of?(HArray) or e.kind_of?(Array) }
-    self.replace(self.flatten)
-  end
-
-  def include?(v)
-    self.has_value?(v)
-  end
-
-  # index okay
-
-  def join(sep='')
-    s = ''
-    (0...self.length).each { |i| s << "#{self.fetch(i)}#{sep}" }
-    return s.chomp(sep)
-  end
-
-  def last
-    self[self.length-1]
-  end
-
-  # length okay
-
-  alias map! collect!
-
-  def nitems
-    cnt = 0
-    (0...self.length).each { |i| cnt += 1 if self.fetch(i) != nil }
-    cnt
-  end
-
-  def pack(*args)
-    self.to_a.pack(*args)
-  end
-
-  def pop
-    self.delete_at(self.length-1)
-  end
-
-  def push(*e)
-    self.concat(e)
-  end
-
-  def rassoc(k)
-    (0...self.length).each { |i| return self.fetch(i) if self.fetch(i)[1] == k }
-    return nil
-  end
-
-  def reindex
-    nha, j, k, tl = HArray.new, 0, 0, self.length
-    while k < tl
-      if self.has_key?(j)
-        nha.set(k,self.fetch(j))
-        j+=1; k+=1
-      else
-        j+=1
-      end
-    end
-    nha
-  end
-
-  def reindex!
-    self.replace(self.reindex)
-  end
-
-  def reject!
-    chg=nil
-    qdelete_if { |i,v| r=yield(v); chg=true if r; r }
-    return nil if !chg
-    reindex!
-  end
-
-  #def replace(ha)
-  #  if ha.length < self.length
-  #    (ha.length..self.length-1).each { |i| self.delete(i) }
-  #    (0..ha.length-1).each { |i| self.set(i,ha[i]) }
-  #  end
-  #end
-
-  def reverse
-    nha = HArray.new
-    (0...self.length).each { |i| nha.set(self.length-1-i,self.fetch(i)) }
-    nha
-  end
-
-  def reverse!
-    (0...self.length/2).each do |i|
-      ri = self.length-1-i
-      tmp = self.fetch(ri)
-      self.set(ri,self.fetch(i))
-      self.set(i,tmp)
-    end
-    self
-  end
-
-  def reverse_each
-    i = self.length - 1
-    while i >= 0
-      yield(self.fetch(i))
-      i -= 1
-    end
-  end
-
-  def rindex(e)
-    i = self.length - 1
-    while i >= 0
-      return i if self.fetch(i) == e
-      i -= 1
-    end
-    return nil
-  end
-
-  def shift
-    e1 = self[0]
-    tl = self.length - 1
-    (1..tl).each { |i| self.set(i-1,self.fetch(i)) }
-    self.delete_at(tl)
-    e1
-  end
-
-  # size okay
-
-  def slice(*args)
-    self[*args]
-  end
-
-  def slice!(*args)
-    result = self[*args]
-    self[*args] = nil
-    result
-  end
-
-  def sort
-    raise "HArray does not currently support sorting with blocks" if block_given?
-    nha = self.dup
-    qsort(nha,0,nha.length-1)
-  end
-
-  def qsort(ha, l, r)
-    l_hold = l
-    r_hold = r
-    pivot = ha[l]
-    while l < r
-      r -= 1 while (ha[r] <=> pivot) >= 0 and l < r
-      if l != r
-        ha[l] = ha[r]
-        l += 1
-      end
-      l += 1 while (ha[l] <=> pivot) <= 0 and l < r
-      if l != r
-        ha[r] = ha[l]
-        r -= 1
-      end
-    end
-    ha[l] = pivot
-    pivot = l
-    l = l_hold
-    r = r_hold
-    qsort(ha,l,pivot-1) if l < pivot
-    qsort(ha,pivot+1,r) if r > pivot
-    ha
-  end
-
-  def sort!
-    raise "HArray does not currently support sorting with blocks" if block_given?
-    qsort(self,0,self.length-1)
-  end
-
-  def to_a
-    a = []
-    (0..self.length-1).each { |i| a << self.fetch(i) }
-    a
-  end
-
-  def to_ary
-    self
-  end
-
-  def to_h
-   h = Hash.new
-   self.each { |k,v| h[k] = v }
-   h
-  end
-
-  def to_s
-   self.join
-  end
-
-  def uniq
-    nha = HArray.new
-    (0..self.length-1).each do |i|
-      nha[nha.length] = self[i] if !nha.has_value?(self[i])
-    end
-    nha
-  end
-
-  def uniq!
-    j = 0
-    (1..self.length-1).each do |i|
-      if !self[0..j].has_value?(self[i])
-        self[j+1] = self[i]
-        j+=1
-      end
-    end
-    (j+1..self.length-1).each { |i| qdelete(i) }
-  end
-
-  def unshift(e)
-    i = self.length - 1
-    while i >= 0
-      self.set(i+1,self.fetch(i))
-      return i if self.fetch(i) == e
-      i -= 1
-    end
-    self.set(0,e)
-    self
-  end
-
-  def values_at(*ix)
-    nha = HArray.new
-    ix.each {|i| nha[nha.length] = self.at(i)}
-    nha
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  # This is a mostly complete testcase for HArray.
-  # HArray is tested by comparison to standard Array.
-
-  require 'test/unit'
-
-  class TC_HArray < Test::Unit::TestCase
-
-    def aha(a)
-      return a, HArray[*a]
-    end
-
-    def test_conversions
-      a, ha = aha [1,3,'a',8,nil,[1]]
-      assert_equal(ha, ha.to_ary)  # these need to be opposite
-      assert_equal(a, ha.to_a)     #
-      assert_equal(a.to_s, ha.to_s)
-    end
-
-    def test_set_operations
-      a, ha = aha [1,3,5,8,9]
-      b, hb = aha [2,3,6,8,9]
-      assert_equal(a | b, (ha | hb).to_a)
-      assert_equal(a & b, (ha & hb).to_a)
-      assert_equal(a + b, (ha + hb).to_a)
-      assert_equal(a - b, (ha - hb).to_a)
-    end
-
-    def test_multiple
-      a, ha = aha [1,3]
-      assert_equal(a*3,(ha*3).to_a)
-    end
-
-    def test_assign
-      a, ha = aha [1,2,3,4]
-      a[1..2] = [8,9]
-      ha[1..2] = [8,9]
-      assert_equal(a, ha.to_a)
-    end
-    def test_assoc
-      a, ha = aha [[1,2],[3,4],[3,6]]
-      assert_equal(a.assoc(3), ha.assoc(3).to_a)
-    end
-    def test_at
-      a, ha = aha [4,5,6,6]
-      assert_equal(a.at(0), ha.at(0))
-      assert_equal(a.at(2), ha.at(2))
-      assert_equal(a.at(4), ha.at(4))
-      assert_equal(a.at(9), ha.at(9))
-      assert_equal(a.at(-1), ha.at(-1))
-      assert_equal(a.at(-3), ha.at(-3))
-      assert_equal(a.at(-4), ha.at(-4))
-      assert_equal(a.at(-5), ha.at(-5))
-    end
-    def test_collect
-      a, ha = aha [4,5,6,6]
-      assert_equal(a.collect{|e|e}, ha.collect{|e|e}.to_a)
-      assert_equal(a.collect!{|e|e}, ha.collect!{|e|e}.to_a)
-      assert_equal(a,ha.to_a)
-    end
-    def test_compact
-      a, ha = aha [4,nil,5,nil,6]
-      assert_equal(a.compact, ha.compact.to_a)
-    end
-    def test_concat
-      a, ha = aha [1,3,5,8,9]
-      b, hb = aha [2,3,6,8,9]
-      assert_equal(a.concat(b),ha.concat(hb).to_a)
-    end
-    def test_count
-      ha = HArray[9,3,9,5,nil,nil,9,3]
-      assert_equal(2,ha.count)
-      assert_equal(2,ha.count(3))
-      assert_equal(3,ha.count{|e|e==9})
-    end
-    def test_delete
-      a, ha = aha [1,3,5,8,9,'a','b','c','c','d']
-      # test delete
-      assert_equal(a.delete(1),ha.delete(1))
-      assert_equal(a,ha.to_a)
-      assert_equal(a.delete('a'),ha.delete('a'))
-      assert_equal(a,ha.to_a)
-      # test delete_at
-      assert_equal(a.delete_at(0),ha.delete_at(0))
-      assert_equal(a,ha.to_a)
-      # test delete_if
-      assert_equal(a.delete_if{|v|v=='c'},ha.delete_if{|v|v=='c'}.to_a)
-      assert_equal(a,ha.to_a)
-    end
-    def test_each
-      a, ha = aha [4,'a',nil,'b']
-      # test each
-      ca, cha = '', ''
-      a.each{|e| ca += e.to_s}
-      ha.each{|e| cha += e.to_s}
-      assert_equal(ca,cha)
-      assert_equal(a,ha.to_a)
-      # test each_index
-      ca, cha = '', ''
-      a.each_index{|i| ca += i.to_s}
-      ha.each_index{|i| cha += i.to_s}
-      assert_equal(ca,cha)
-      assert_equal(a,ha.to_a)
-    end
-    def test_eql?
-      a, ha = aha [4,'a',nil,'b']
-      b, hb = aha [4,'a',nil,'b']
-      assert_equal(a,b)
-      assert_equal(ha,hb)
-      assert_equal(a.eql?(b),ha.eql?(hb))
-      assert_equal(b.eql?(a),hb.eql?(ha))
-      assert(ha.eql?(hb))
-      assert(hb.eql?(ha))
-    end
-    def test_empty?
-      a, ha = aha []
-      assert_equal(a.empty?,ha.empty?)
-      a, ha = aha [1,2,3]
-      assert_equal(a.empty?,ha.empty?)
-    end
-    def test_fill
-      a, ha = aha ['a','b','c','d']
-      assert_equal(a.fill('x'),ha.fill('x').to_a)
-      assert_equal(a,ha.to_a)
-      assert_equal(a.fill('y',2,2),ha.fill('y',2,2).to_a)
-      assert_equal(a,ha.to_a)
-      assert_equal(a.fill('z',0..1),ha.fill('z',0..1).to_a)
-      assert_equal(a,ha.to_a)
-    end
-    def test_first
-      a, ha = aha [2,3,4]
-      assert_equal(a.first,ha.first)
-    end
-    def test_flatten
-      a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
-      assert_equal(a.flatten,ha.flatten.to_a)
-      a, ha = aha [2,[3],'a',[[1,2],4],nil,5]
-      assert_equal(a.flatten!,ha.flatten!.to_a)
-      assert_equal(a,ha.to_a)
-      a, ha = aha [2,3,'a',nil,5]
-      assert_equal(a.flatten!,ha.flatten!)
-    end
-    def test_include?
-      a, ha = aha ['a','b','c','d']
-      assert_equal(a.include?('b'),ha.include?('b'))
-      assert_equal(a.include?('x'),ha.include?('x'))
-    end
-    def test_index
-      a, ha = aha ['a','b','b','c','d']
-      assert_equal(a.index('b'),ha.index('b'))
-      assert_equal(a.index('x'),ha.index('x'))
-    end
-    def test_join
-      a, ha = aha [2,3,4]
-      assert_equal(a.join,ha.join)
-      assert_equal(a.join(','),ha.join(','))
-    end
-    def test_last
-      a, ha = aha [2,3,4]
-      assert_equal(a.last,ha.last)
-    end
-    def test_length
-      a, ha = aha [2,3,4]
-      assert_equal(a.length,ha.length)
-    end
-    def test_map!
-      a, ha = aha [4,5,6,6]
-      assert_equal(a.map!{|e|e}, ha.map!{|e|e}.to_a)
-      assert_equal(a,ha.to_a)
-    end
-    def test_nitems
-      a, ha = aha [4,5,nil,6,nil]
-      assert_equal(a.nitems, ha.nitems)
-    end
-    def test_pop
-      a, ha = aha [4,5,nil,6,nil]
-      assert_equal(a.pop, ha.pop)
-      assert_equal(a, ha.to_a)
-      assert_equal(a.pop, ha.pop)
-      assert_equal(a, ha.to_a)
-    end
-    def test_push
-      a, ha = aha [4,5,nil,6,nil]
-      args = [1,2,3]
-      assert_equal(a.push(*args), ha.push(*args).to_a)
-      assert_equal(a, ha.to_a)
-    end
-    def test_rassoc
-      a, ha = aha [[1,2],[1,3],[1,3]]
-      assert_equal(a.rassoc(3), ha.rassoc(3).to_a)
-    end
-    def test_reject!
-      a, ha = aha ['a','b','c','c','d']
-      assert_equal(a.reject!{|v|v=='c'},ha.reject!{|v|v=='c'}.to_a)
-      assert_equal(a,ha.to_a)
-      assert_equal(a.reject!{|v|v=='x'},ha.reject!{|v|v=='x'})
-      assert_equal(a,ha.to_a)
-    end
-    def test_reverse
-      a, ha = aha ['a','b','c','c','d']
-      assert_equal(a.reverse,ha.reverse.to_a)
-      assert_equal(a.reverse!,ha.reverse!.to_a)
-      assert_equal(a,ha.to_a)
-      a, ha = aha [1,2,3,'a','b','c']
-      assert_equal(a.reverse!,ha.reverse!.to_a)
-      assert_equal(a,ha.to_a)
-    end
-    def test_reverse_each
-      a, ha = aha [4,'a',nil,'b']
-      # test each
-      ca, cha = '', ''
-      a.reverse_each{|e| ca += e.to_s}
-      ha.reverse_each{|e| cha += e.to_s}
-      assert_equal(ca,cha)
-      assert_equal(a,ha.to_a)
-    end
-    def test_rindex
-      a, ha = aha ['a','b','c','c','d']
-      assert_equal(a.rindex('c'),ha.rindex('c'))
-      assert_equal(a.rindex('x'),ha.rindex('x'))
-    end
-    def test_shift
-      a, ha = aha ['a','b','c','c','d']
-      assert_equal(a.shift,ha.shift)
-      assert_equal(a,ha.to_a)
-    end
-
-    def test_slice
-      a, ha = aha [1,2,3,4]
-      # test []
-      assert_equal(a[1], ha[1])
-      assert_equal(a[1..2], ha[1..2].to_a)
-      assert_equal(a[1...2], ha[1...2].to_a)
-      assert_equal(a[1..7], ha[1..7].to_a)
-      assert_equal(a[1,2], ha[1,2].to_a)
-      # test slice
-      assert_equal(a.slice(1), ha.slice(1))
-      assert_equal(a.slice(1..2), ha.slice(1..2).to_a)
-      assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
-      assert_equal(a.slice(1...2), ha.slice(1...2).to_a)
-      assert_equal(a.slice(1,2), ha.slice(1,2).to_a)
-      # test slice!
-      assert_equal(a.slice!(1..2), ha.slice!(1..2).to_a)
-      assert_equal(a, ha.to_a)
-    end
-
-    def test_sort
-      a, ha = aha [1,2,3,4]
-      # test sort
-      assert_equal(a.sort, ha.sort.to_a)
-      #assert_equal(a.sort{|x,y| y<=>x}, ha.sort{|x,y| y<=>x}.to_a)
-      # test sort!
-      assert_equal(a.sort!, ha.sort!.to_a)
-      assert_equal(a, ha.to_a)
-    end
-
-    def test_uniq
-      a, ha = aha [1,1,2,3,3,4,5,6,6]
-      assert_equal(a.uniq, ha.uniq.to_a)
-    end
-
-    def test_uniq!
-      a, ha = aha [1,1,2,3,3,4,5,6,6]
-      a.uniq!; ha.uniq!
-      assert_equal(a, ha.to_a)
-    end
-
-    def test_values_at
-      a, ha = aha ['a','b','c','d']
-      assert_equal(a.values_at(1,3),ha.values_at(1,3).to_a)
-    end
-
-    def test_unshift
-      a, ha = aha ['a','b','c','c','d']
-      assert_equal(a.unshift('x'),ha.unshift('x').to_a)
-      assert_equal(a,ha.to_a)
-    end
-  end
-
-=end