get rid of old SVN structure
This commit is contained in:
Ward Wouts
parent
64eaf7c89f
commit
08e83501be
324 changed files with 0 additions and 70245 deletions
915
set/intspan.rb
Normal file
915
set/intspan.rb
Normal file
|
|
@ -0,0 +1,915 @@
|
|||
# $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
|
||||
Loading…
Add table
Add a link
Reference in a new issue