915 lines
16 KiB
Ruby
915 lines
16 KiB
Ruby
# $Dwarf: intspan.rb,v 1.20 2005/03/11 12:17:35 ward Exp $
|
|
# $Source$
|
|
|
|
#
|
|
# Copyright (c) 2002, 2003 Ward Wouts <ward@wouts.nl>
|
|
#
|
|
# Permission to use, copy, modify, and distribute this software for any
|
|
# purpose with or without fee is hereby granted, provided that the above
|
|
# copyright notice and this permission notice appear in all copies.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
#
|
|
|
|
class Integer
|
|
def even?
|
|
return self%2 == 0
|
|
end
|
|
|
|
def odd?
|
|
return self%2 == 1
|
|
end
|
|
end
|
|
|
|
module Set
|
|
|
|
class IntSpan
|
|
|
|
Empty_String = ''
|
|
Debuglevel = 0
|
|
|
|
def initialize(setspec=nil)
|
|
print "initialize: Calling copy\n" if Debuglevel > 0
|
|
copy(setspec)
|
|
end
|
|
|
|
def IntSpan.valid(run_list)
|
|
testset = new
|
|
begin
|
|
testset._copy_run_list(run_list)
|
|
rescue SystemExit
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
def copy(set_spec)
|
|
print "Copy #{set_spec.class.to_s}\n" if Debuglevel > 0
|
|
case set_spec.class.to_s
|
|
when "NilClass"
|
|
print "copy: Calling _copy_empty\n" if Debuglevel > 0
|
|
_copy_empty
|
|
when "String"
|
|
print "copy: Calling _copy_run_list\n" if Debuglevel > 0
|
|
_copy_run_list(set_spec)
|
|
when "Array"
|
|
print "copy: Calling _copy_array\n" if Debuglevel > 0
|
|
_copy_array(set_spec)
|
|
when "Set::IntSpan"
|
|
print "copy: Calling _copy_set\n" if Debuglevel > 0
|
|
_copy_set(set_spec)
|
|
else
|
|
print "eeps\n"
|
|
end
|
|
end
|
|
|
|
def _copy_empty # makes @set the empty set
|
|
@set = {}
|
|
set_neg_inf(false)
|
|
set_pos_inf(false)
|
|
@set["edges"] = []
|
|
@set["run"] = []
|
|
end
|
|
|
|
def _copy_array(array) # copies an array into @set
|
|
_copy_empty
|
|
set_neg_inf(false)
|
|
set_pos_inf(false)
|
|
|
|
edges = []
|
|
for element in array.sort
|
|
next if (edges.length > 0) and (edges[-1] == element) # skip duplicates
|
|
|
|
if (edges.length > 0) and (edges[-1] == element-1)
|
|
edges[-1] = element
|
|
else
|
|
edges.push(element-1, element)
|
|
end
|
|
end
|
|
|
|
@set["edges"] = edges
|
|
@set["run"] = []
|
|
end
|
|
|
|
def _copy_set(src) # copies one set to another
|
|
_copy_empty
|
|
set_neg_inf(src.neg_inf?)
|
|
set_pos_inf(src.pos_inf?)
|
|
@set["edges"] = src.edges
|
|
@set["run"] = []
|
|
end
|
|
|
|
def _copy_run_list(runlist)
|
|
_copy_empty
|
|
|
|
runlist.gsub!(/\s|_/, '')
|
|
return true if runlist == ""
|
|
|
|
print "copy run list...\n" if Debuglevel > 0
|
|
|
|
first = true
|
|
last = false
|
|
|
|
edges = []
|
|
|
|
for i in runlist.split(/,/)
|
|
print "#{i}\n" if Debuglevel > 0
|
|
begin
|
|
if i =~ /^(-?\d+)$/x
|
|
edges.push(($1.to_i-1), $1.to_i)
|
|
next
|
|
end
|
|
|
|
if i =~ /^ (-?\d+) - (-?\d+) $/x
|
|
if $1.to_i > $2.to_i
|
|
print "match rule 1 #{$1} > #{$2}\n"
|
|
print "Set::IntSpan::_copy_run_list: Bad order: #{runlist}\n"
|
|
exit
|
|
else
|
|
edges.push(($1.to_i-1), $2.to_i)
|
|
next
|
|
end
|
|
end
|
|
|
|
if i =~ /^\(-(-?\d+)$/x
|
|
unless first
|
|
print "match rule 2\n"
|
|
print "Set::IntSpan::_copy_run_list: Bad order: #{runlist}\n"
|
|
exit
|
|
end
|
|
set_neg_inf(true)
|
|
edges.push($1.to_i)
|
|
next
|
|
end
|
|
|
|
if i =~ /^(-?\d+)-\)$/x
|
|
# print "match rule 3\n"
|
|
edges.push(($1.to_i-1))
|
|
set_pos_inf(true)
|
|
last = true
|
|
next
|
|
end
|
|
|
|
if i =~ /^\(-\)$/x
|
|
unless first
|
|
print "match rule 4\n"
|
|
print "Set::IntSpan::_copy_run_list: Bad order: #{runlist}\n"
|
|
exit
|
|
end
|
|
set_neg_inf(true)
|
|
set_pos_inf(true)
|
|
last = true
|
|
next
|
|
end
|
|
|
|
print "no match! \"#{i}\"\n"
|
|
print "Set::IntSpan::_copy_run_list: Bad syntax: #{runlist}\n"
|
|
end
|
|
first = false
|
|
end
|
|
|
|
@set["edges"] = edges
|
|
@set["run"] = []
|
|
|
|
return true
|
|
end
|
|
|
|
#def splice(array, offset, length=nil, list=[])
|
|
# if offset >= 0
|
|
# length = array.length-offset unless length
|
|
# leftarray = array.slice(0, offset)
|
|
# rightarray = array.slice(offset+length, (array.length - offset))
|
|
# else
|
|
# length = array.length+offset unless length
|
|
# leftarray = array.slice(0, (array.length+offset))
|
|
# rightarray = array.slice(array.length+length+offset, array.length+offset)
|
|
# end
|
|
#
|
|
# array = leftarray
|
|
# array += list
|
|
# array += rightarray if rightarray
|
|
#
|
|
# return array
|
|
#end
|
|
|
|
def to_s
|
|
return run_list
|
|
end
|
|
|
|
def run_list
|
|
if empty?
|
|
return Empty_String
|
|
end
|
|
|
|
print "edges leng: ", @set["edges"].length, "\n" if Debuglevel > 0
|
|
edges = []
|
|
edges.concat(@set["edges"])
|
|
runs = []
|
|
|
|
if edges.length > 0
|
|
edges.unshift('(') if neg_inf?
|
|
edges.push(')') if pos_inf?
|
|
|
|
print edges.join("/"),"\n" if Debuglevel > 0
|
|
|
|
i = 0
|
|
while i < edges.length
|
|
print "edges leng: ", @set["edges"].length, "\n" if Debuglevel > 0
|
|
lower = edges[i]
|
|
i += 1
|
|
upper = edges[i]
|
|
i += 1
|
|
print "Lower: \"#{lower}\" Upper: \"#{upper}\"\n" if Debuglevel > 0
|
|
if !(lower.to_s == '(') and !(upper.to_s == ')') and ((lower+1) == upper)
|
|
print "#{upper}\n" if Debuglevel > 0
|
|
runs.push("#{upper}")
|
|
else
|
|
lower += 1 if (lower.to_s <=> "(")!=0
|
|
print "#{lower}-#{upper}\n" if Debuglevel > 0
|
|
runs.push("#{lower}-#{upper}")
|
|
end
|
|
end
|
|
end
|
|
|
|
print "edges leng: ", @set["edges"].length, "\n" if Debuglevel > 0
|
|
|
|
return runs.join(',')
|
|
end
|
|
|
|
def elements
|
|
if infinite?
|
|
print "Set::IntSpan::elements: infinite set\n"
|
|
exit
|
|
end
|
|
|
|
elements = []
|
|
edges = @set["edges"].dup
|
|
while (edges.length>0)
|
|
lower, upper = edges.slice!(0..1)
|
|
elements += (lower+1 .. upper).to_a
|
|
end
|
|
|
|
return elements
|
|
end
|
|
|
|
def _real_set(set_spec=nil) # converts a set specification into a set
|
|
(set_spec != nil and set_spec.class.to_s == "Set::IntSpan") ?
|
|
set_spec :
|
|
IntSpan.new(set_spec)
|
|
end
|
|
|
|
def union(set_spec)
|
|
b = _real_set(set_spec)
|
|
s = IntSpan.new
|
|
|
|
s.set_neg_inf(neg_inf? || b.neg_inf?)
|
|
|
|
eA = @set["edges"]
|
|
eB = b.edges
|
|
eS = s.edges
|
|
|
|
inA = neg_inf?
|
|
inB = b.neg_inf?
|
|
|
|
iA = 0
|
|
iB = 0
|
|
|
|
while (iA < eA.length and iB < eB.length)
|
|
xA = eA[iA]
|
|
xB = eB[iB]
|
|
|
|
if (xA < xB)
|
|
iA += 1
|
|
inA = ! inA
|
|
not inB and eS.push(xA)
|
|
elsif (xB < xA)
|
|
iB += 1
|
|
inB = ! inB
|
|
not inA and eS.push(xB)
|
|
else
|
|
iA += 1
|
|
iB += 1
|
|
inA = ! inA
|
|
inB = ! inB
|
|
inA == inB and eS.push(xA)
|
|
end
|
|
end
|
|
|
|
iA < eA.length and (! inB) and eS.concat(eA[iA..eA.length])
|
|
iB < eB.length and (! inA) and eS.concat(eB[iB..eB.length])
|
|
|
|
s.set_pos_inf(pos_inf? || b.pos_inf?)
|
|
s.set_edges(eS)
|
|
|
|
return s
|
|
end
|
|
|
|
def intersect(set_spec)
|
|
b = _real_set(set_spec)
|
|
s = IntSpan.new
|
|
|
|
s.set_neg_inf(neg_inf? && b.neg_inf?)
|
|
|
|
eA = @set["edges"]
|
|
eB = b.edges
|
|
eS = s.edges
|
|
|
|
inA = neg_inf?
|
|
inB = b.neg_inf?
|
|
|
|
iA = 0
|
|
iB = 0
|
|
|
|
while (iA < eA.length and iB < eB.length)
|
|
xA = eA[iA]
|
|
xB = eB[iB]
|
|
|
|
if (xA < xB)
|
|
iA += 1
|
|
inA = ! inA
|
|
inB and eS.push(xA)
|
|
elsif (xB < xA)
|
|
iB += 1
|
|
inB = ! inB
|
|
inA and eS.push(xB)
|
|
else
|
|
iA += 1
|
|
iB += 1
|
|
inA = ! inA
|
|
inB = ! inB
|
|
inA == inB and eS.push(xA)
|
|
end
|
|
end
|
|
|
|
iA < eA.length and inB and eS.concat(eA[iA..eA.length])
|
|
iB < eB.length and inA and eS.concat(eB[iB..eB.length])
|
|
|
|
s.set_neg_inf(pos_inf? && b.pos_inf?)
|
|
s.set_edges(eS)
|
|
return s
|
|
end
|
|
|
|
def diff (set_spec)
|
|
b = _real_set(set_spec)
|
|
s = IntSpan.new
|
|
|
|
s.set_neg_inf(neg_inf? && ! b.neg_inf?)
|
|
|
|
eA = @set["edges"]
|
|
eB = b.edges
|
|
eS = s.edges
|
|
|
|
inA = neg_inf?
|
|
inB = b.neg_inf?
|
|
|
|
iA = 0
|
|
iB = 0
|
|
|
|
while (iA < eA.length and iB < eB.length)
|
|
xA = eA[iA]
|
|
xB = eB[iB]
|
|
|
|
if (xA < xB)
|
|
iA += 1
|
|
inA = ! inA
|
|
not inB and eS.push(xA)
|
|
elsif (xB < xA)
|
|
iB += 1
|
|
inB = ! inB
|
|
inA and eS.push(xB)
|
|
else
|
|
iA += 1
|
|
iB += 1
|
|
inA = ! inA
|
|
inB = ! inB
|
|
inA != inB and eS.push(xA)
|
|
end
|
|
end
|
|
|
|
iA < eA.length and not inB and eS.concat(eA[iA..eA.length])
|
|
iB < eB.length and inA and eS.concat(eB[iB..eB.length])
|
|
|
|
s.set_edges(eS)
|
|
|
|
s.set_pos_inf(pos_inf? && ! b.pos_inf?)
|
|
return s
|
|
end
|
|
|
|
def xor(set_spec)
|
|
b = _real_set(set_spec)
|
|
s = IntSpan.new
|
|
|
|
s.set_neg_inf(neg_inf? ^ b.neg_inf?)
|
|
|
|
eA = @set["edges"]
|
|
eB = b.edges
|
|
eS = s.edges
|
|
|
|
iA = 0
|
|
iB = 0
|
|
|
|
while (iA < eA.length and iB < eB.length)
|
|
xA = eA[iA]
|
|
xB = eB[iB]
|
|
|
|
if (xA < xB)
|
|
iA += 1
|
|
eS.push(xA)
|
|
elsif (xB < xA)
|
|
iB += 1
|
|
eS.push(xB)
|
|
else
|
|
iA += 1
|
|
iB += 1
|
|
end
|
|
end
|
|
|
|
iA < eA.length and eS.concat(eA[iA..eA.length])
|
|
iB < eB.length and eS.concat(eB[iB..eB.length])
|
|
|
|
s.set_pos_inf(pos_inf? ^ b.pos_inf?)
|
|
s.set_edges(eS)
|
|
return s
|
|
end
|
|
|
|
def complement
|
|
# complement is inverse set; dit klopt hier dus niet
|
|
a = first
|
|
b = last
|
|
|
|
print "first #{a} last #{b}\n" if Debuglevel > 0
|
|
if a!=b
|
|
s = IntSpan.new("#{a}-#{b}")
|
|
comp = xor(s)
|
|
else
|
|
comp = IntSpan.new("#{a}")
|
|
end
|
|
|
|
if Debuglevel > 0
|
|
while i = comp.next
|
|
print "#{i}\n"
|
|
end
|
|
end
|
|
|
|
comp.set_neg_inf(! comp.neg_inf?)
|
|
comp.set_pos_inf(! comp.pos_inf?)
|
|
return comp
|
|
end
|
|
|
|
def superset(set_spec)
|
|
b = _real_set(set_spec)
|
|
|
|
s = b.diff(self)
|
|
return s.empty?
|
|
end
|
|
|
|
def subset(set_spec)
|
|
b = _real_set(set_spec)
|
|
|
|
s = diff(b)
|
|
return s.empty?
|
|
end
|
|
|
|
def equal(set_spec)
|
|
b = _real_set(set_spec)
|
|
|
|
print "a\n"
|
|
neg_inf? == b.neg_inf? or return false
|
|
print "b\n"
|
|
pos_inf? == b.pos_inf? or return false
|
|
|
|
aEdge = @set["edges"]
|
|
bEdge = b.edges
|
|
print "aEdge #{aEdge.length} bEdge #{bEdge.length}\n"
|
|
aEdge.length == bEdge.length or return false
|
|
print "c\n"
|
|
|
|
for i in (0...aEdge.length)
|
|
aEdge[i] == bEdge[i] or return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
def equivalent(set_spec)
|
|
b = _real_set(set_spec)
|
|
|
|
cardinality == b.cardinality
|
|
end
|
|
|
|
def cardinality
|
|
(neg_inf? or pos_inf?) and return -1
|
|
|
|
car = 0
|
|
edges = @set["edges"]
|
|
i=0
|
|
while (i < edges.length)
|
|
lower = edges[i]
|
|
upper = edges[i+1]
|
|
car += upper - lower
|
|
i += 2
|
|
end
|
|
|
|
return car
|
|
end
|
|
|
|
def empty?
|
|
if neg_inf? || pos_inf? || @set["edges"].length > 0
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
def edges
|
|
return @set["edges"]
|
|
end
|
|
|
|
def set_edges(edges)
|
|
@set["edges"] = edges
|
|
end
|
|
|
|
def neg_inf?
|
|
return @set["negInf"]
|
|
end
|
|
|
|
def set_neg_inf(negInf)
|
|
@set["negInf"] = negInf
|
|
end
|
|
|
|
def pos_inf?
|
|
return @set["posInf"]
|
|
end
|
|
|
|
def set_pos_inf(posInf)
|
|
@set["posInf"] = posInf
|
|
end
|
|
|
|
def finite?
|
|
return (! neg_inf? and ! pos_inf?)
|
|
end
|
|
|
|
def infinite?
|
|
return ! finite?
|
|
end
|
|
|
|
def universal
|
|
neg_inf? and not @set["edges"].length > 0 and pos_inf?
|
|
end
|
|
|
|
# XXX this should probably have some recursion to make it faster
|
|
def member?(n)
|
|
inSet = neg_inf?
|
|
edge = @set["edges"]
|
|
|
|
for i in (0...edge.length)
|
|
if inSet
|
|
return true if n <= edge[i]
|
|
inSet = false
|
|
else
|
|
return false if n <= edge[i]
|
|
inSet = true
|
|
end
|
|
end
|
|
|
|
inSet
|
|
end
|
|
|
|
def insert!(n)
|
|
if @set["edges"].empty?
|
|
@set["edges"] = [n-1, n]
|
|
return
|
|
end
|
|
|
|
if n == @set["edges"][-1]+1
|
|
@set["edges"][-1] += 1
|
|
return
|
|
elsif n > @set["edges"][-1]
|
|
@set["edges"].push(n-1, n)
|
|
return
|
|
end
|
|
|
|
# XXX dit kan vast netter... toch de Dijkstra neuronen nog eens aansteken
|
|
# XXX this should probably have some recursion to make it faster
|
|
l = 0
|
|
r = @set["edges"].length-1
|
|
i = r/2
|
|
while true
|
|
if n < @set["edges"][i] && n > @set["edges"][i-1]
|
|
inSet = i.odd?
|
|
break
|
|
elsif n < @set["edges"][i] && i == 0
|
|
inSet = false
|
|
break
|
|
elsif n < @set["edges"][i]
|
|
r = i
|
|
i = l + ((r-l)/2)
|
|
# tikkeltje sneller dan neg_inf? aanroepen
|
|
inSet = @set["negInf"]
|
|
elsif n == @set["edges"][i]
|
|
inSet = i.odd?
|
|
break
|
|
else
|
|
l = i
|
|
i = l + ((r-l)/2)
|
|
end
|
|
end
|
|
|
|
inSet and return
|
|
|
|
lGap = i == 0 || n-1 - @set["edges"][i-1]
|
|
lGap = false if lGap == 0
|
|
|
|
rGap = i == @set["edges"].length-1 ? i : @set["edges"][i] - n
|
|
rGap = false if rGap == 0
|
|
|
|
if ( lGap and rGap)
|
|
@set["edges"].insert(i, n-1, n)
|
|
elsif (not lGap and rGap)
|
|
@set["edges"][i-1] += 1
|
|
elsif ( lGap and not rGap)
|
|
@set["edges"][i] -= 1
|
|
else
|
|
@set["edges"].slice!(i-1, 2)
|
|
end
|
|
end
|
|
|
|
def remove!(n)
|
|
n or return
|
|
|
|
inSet = neg_inf?
|
|
edge = @set["edges"]
|
|
|
|
for i in (0...edge.length)
|
|
if (inSet)
|
|
break if n <= edge[i]
|
|
inSet = false
|
|
else
|
|
return if n <= edge[i]
|
|
inSet = true
|
|
end
|
|
end
|
|
|
|
return unless inSet
|
|
|
|
for i in (0...edge.length)
|
|
if edge[i] == n-1 and edge[i+1] == n
|
|
lower = edge[0...i]
|
|
upper = edge[i+2..edge.length]
|
|
edge = lower + upper
|
|
break
|
|
elsif edge[i] == n-1
|
|
edge[i] += 1
|
|
break
|
|
elsif edge[i] == n
|
|
edge[i] += 1
|
|
break
|
|
elsif edge[i+1] == n
|
|
edge[i+1] -= 1
|
|
break
|
|
elsif edge[i]<n and edge[i+1]>n
|
|
lower = edge[0..i]
|
|
upper = edge[i+1..edge.length]
|
|
edge = lower + [n-1, n] +upper
|
|
break
|
|
end
|
|
i += 1
|
|
end
|
|
|
|
@set["edges"] = edge
|
|
return self
|
|
end
|
|
|
|
def min
|
|
empty? and return nil
|
|
neg_inf? and return nil
|
|
@set["edges"][0]+1
|
|
end
|
|
|
|
def max
|
|
empty? and return nil
|
|
pos_inf? and return nil
|
|
@set["edges"][-1]
|
|
end
|
|
|
|
def grep_set(block)
|
|
return nil if neg_inf? or pos_inf?
|
|
|
|
edges = @set["edges"]
|
|
sub_edges = []
|
|
|
|
while (edges.length > 0)
|
|
lower, upper = edges.slice!(0..1)
|
|
#lower = edges[0]
|
|
#upper = edges[1]
|
|
#edges = edges.slice(2..edges.length)
|
|
|
|
for i in (lower+1..upper)
|
|
# local $_ = i
|
|
# &$block() or next # definately wrong, must eval block
|
|
|
|
if (sub_edges.length > 0 and sub_edges[-1] == i-1)
|
|
sub_edges[-1] = i
|
|
else
|
|
sub_edges += [ i-1, i ]
|
|
end
|
|
end
|
|
end
|
|
|
|
sub_set = new
|
|
sub_set["edges"] = sub_edges
|
|
sub_set
|
|
end
|
|
|
|
def map_set(block)
|
|
return nil if neg_inf? or pos_inf?
|
|
|
|
map_set = new
|
|
|
|
edges = @set["edges"]
|
|
while (edges.length > 0)
|
|
lower, upper = edges.slice!(0..1)
|
|
#lower = edges[0]
|
|
#upper = edges[1]
|
|
#edges = edges.slice(2..edges.length)
|
|
|
|
for domain in (lower+1..upper)
|
|
local $_ = domain;
|
|
|
|
# for range (&$block()) # definately wrong, must eval block
|
|
# map_set.insert(range)
|
|
# end
|
|
end
|
|
end
|
|
|
|
map_set
|
|
end
|
|
|
|
def first
|
|
@set["iterator"] = min
|
|
@set["run"] = []
|
|
@set["run"][0] = 0
|
|
@set["run"][1] = @set["edges"].length > 0 ? 1 : nil
|
|
|
|
@set["iterator"]
|
|
end
|
|
|
|
def last
|
|
lastEdge = @set["edges"].length - 1
|
|
@set["iterator"] = max
|
|
@set["run"][0] = lastEdge > 0 ? lastEdge-1 : nil
|
|
@set["run"][1] = lastEdge
|
|
|
|
@set["iterator"]
|
|
end
|
|
|
|
def start(startval)
|
|
set["iterator"] = nil
|
|
startval or return nil
|
|
|
|
inSet = neg_inf?
|
|
edges = @set["edges"]
|
|
|
|
for i in (0...edges.length)
|
|
if (inSet)
|
|
if (startval <= edges[i])
|
|
@set["iterator"] = startval
|
|
@set["run"][0] = i ? i-1 : nil
|
|
@set["run"][1] = i
|
|
return $startval
|
|
end
|
|
inSet = false
|
|
else
|
|
if (startval <= edges[i])
|
|
return nil
|
|
end
|
|
inSet = true
|
|
end
|
|
end
|
|
|
|
if (inSet)
|
|
@set["iterator"] = startval
|
|
@set["run"][0] = edges.length > 0 ? edges.length: nil
|
|
@set["run"][1] = nil
|
|
end
|
|
|
|
@set["iterator"]
|
|
end
|
|
|
|
def current
|
|
@set["iterator"]
|
|
end
|
|
|
|
def next
|
|
@set["iterator"] or return first
|
|
|
|
run1 = @set["run"][1]
|
|
run1 or return ++@set["iterator"]
|
|
|
|
edges = @set["edges"]
|
|
if (@set["iterator"] < edges[run1])
|
|
@set["iterator"] += 1
|
|
return @set["iterator"]
|
|
end
|
|
|
|
if (run1 < edges.length-2)
|
|
run0 = run1 + 1
|
|
@set["run"] = [run0, run0+1]
|
|
@set["iterator"] = edges[run0]+1
|
|
elsif (run1 < edges.length-1)
|
|
run0 = run1 + 1
|
|
@set["run"] = [run0, nil]
|
|
@set["iterator"] = edges[run0]+1
|
|
else
|
|
@set["iterator"] = nil
|
|
end
|
|
|
|
@set["iterator"]
|
|
end
|
|
|
|
def prev
|
|
@set["iterator"] or return last
|
|
|
|
run0 = @set["run"][0]
|
|
run0 or return --@set["iterator"]
|
|
|
|
edges = @set["edges"]
|
|
|
|
if (@set["iterator"] > edges[run0]+1)
|
|
@set["iterator"] -= 1
|
|
return @set["iterator"]
|
|
end
|
|
|
|
if (run0 > 1)
|
|
run1 = run0 - 1
|
|
@set["run"] = [run1-1, run1]
|
|
@set["iterator"] = edges[run1]
|
|
elsif (run0 > 0)
|
|
run1 = run0 - 1
|
|
@set["run"] = [nil, run1]
|
|
@set["iterator"] = edges[run1]
|
|
else
|
|
@set["iterator"] = nil
|
|
end
|
|
|
|
@set["iterator"]
|
|
end
|
|
|
|
end # class
|
|
|
|
end # module
|
|
|
|
|
|
# TODO
|
|
# Do not kill an item until it's tested!
|
|
|
|
# [x] new
|
|
# [x] valid
|
|
# [ ] copy
|
|
# [ ] _copy_empty # makes $set the empty set
|
|
# [x] _copy_array # copies an array into a set
|
|
# [ ] _copy_set # copies one set to another
|
|
# [ ] _copy_run_list # parses a run list
|
|
# [x] run_list
|
|
# [x] elements
|
|
# [x] _real_set # converts a set specification into a set
|
|
# [x] union
|
|
# [x] intersect
|
|
# [x] diff
|
|
# [x] xor
|
|
# [ ] complement
|
|
# [x] superset
|
|
# [x] subset
|
|
# [x] equal
|
|
# [x] equivalent
|
|
# [x] cardinality
|
|
# [x] empty?
|
|
# [x] finite
|
|
# [x] neg_inf? { shift->{negInf} }
|
|
# [x] pos_inf? { shift->{posInf} }
|
|
# [x] infinite
|
|
# [ ] universal
|
|
# [x] member
|
|
# [x] insert # way to much code i think
|
|
# [x] remove
|
|
# [x] min
|
|
# [x] max
|
|
# [ ] grep_set(&$)
|
|
# [ ] map_set(&$)
|
|
# [x] first($)
|
|
# [x] last($)
|
|
# [ ] start($$)
|
|
# [x] current($) { shift->{iterator} }
|
|
# [x] next($)
|
|
# [x] prev($)
|
|
|
|
# New methods
|
|
# [x] set_neg_inf
|
|
# [x] set_pos_inf
|
|
# [x] set_edges
|
|
# [x] edges
|