extract-curves 0.1.1

data/ruby_libs/pav/set.rb

@@ -0,0 +1,130 @@
+require 'set'
+require 'pav/search'
+
+class SortedArrSet
+	attr_reader :arr, :comparator
+	
+	def initialize(arr, &comparator)
+		@arr = arr
+		@comparator = comparator
+	end
+	
+	def include?(m)
+		PSearch.bsearch(@arr, m, &@comparator) >= 0
+	end
+	
+	alias_method :member?, :include?
+	
+	def method_missing(id, *args, &block)
+		@arr.send(id, *args, &block)
+	end
+end
+
+class ObjIdSet < Hash
+	def initialize
+		super(0)
+	end
+	
+	def add(obj)
+		self[obj.object_id] += 1
+		self
+	end
+	
+	alias_method :<<, :add
+	
+	def push(obj)
+		self[obj.object_id] += 1
+		obj
+	end
+	
+	def pop_obj(obj)
+		if (left = (self[obj.object_id] -= 1)) < 1
+			warn("#{self.class.name}.pop_obj: Obj. not in set: #{
+				obj}!") if left < 0
+			self.delete(obj)
+		end
+	end
+	
+	def delete(obj)
+		super(obj.object_id)
+	end
+	
+	def member?(obj)
+		super(obj.object_id)
+	end
+	
+	alias_method :include?, :member?
+	
+	def each
+		self.each_key { |oid| yield(ObjectSpace._id2ref(oid)) }
+	end
+	
+	alias_method :each_value, :each
+	
+	def to_a
+		res = []
+		self.each { |obj| res << obj }
+		res
+	end
+	
+	def first
+		self.each { |res| return res }
+		nil
+	end
+end
+
+class ObjIdSetWithArr < Array
+	attr_reader :set
+	
+	def initialize
+		@set = Hash.new(0)
+		super()
+	end
+	
+	def <<(obj)
+		@set[obj.object_id] += 1
+		super(obj)
+		self
+	end
+	
+	alias_method :add, :<<
+	
+	def push(obj)
+		@set[obj.object_id] += 1
+		super(obj)
+	end
+	
+	def pop
+		if self.empty?
+			return nil
+		else
+			@set[(res=super).object_id] -= 1
+			res
+		end
+	end
+	
+	def member?(obj)
+		@set.member?(obj.object_id)
+	end
+	
+	alias_method :include?, :member?
+	
+	def pop_obj(obj)
+		if (left = (@set[obj.object_id] -= 1)) < 1
+			@set.delete(obj.object_id)
+			if left < 0
+			  warn("#{self.class.name}.pop_obj: Obj. not in set: #{
+				obj}!")
+			  return
+			end
+		end
+		i = 0
+		while i < self.length
+			if obj.equal?(self.at(i))
+				self.delete_at(i)
+				return
+			end
+			i += 1
+		end
+	end
+end

data/ruby_libs/pav/string/bits.rb

@@ -0,0 +1,523 @@
+require 'sync'
+require 'pav/string/observable'
+
+class BitArr
+	attr_reader :str, :length
+	
+	include Sync_m
+	include Enumerable
+	include Comparable
+	
+	alias_method :__ba_sync_init__, :initialize
+	protected :__ba_sync_init__
+	
+	def initialize(bits="", length=nil)
+		if bits.kind_of? String
+			@length = length
+			if !length
+				@str = bits
+				@length = @str.length * 8
+			else
+				str_len = @length/8 + (@length%8 == 0 ? 0 : 1)
+				@str = bits[0, str_len]
+				@str << "\0" * (str_len - @str.length) if
+					str_len > @str.length
+				@str[str_len-1] &= (0xff >> 8 - length % 8) if
+					length % 8 != 0
+			end
+			self.__ba_sync_init__()
+		elsif bits.kind_of? Array
+			@str = "\0" * ((bits.length/8)+(bits.length%8==0 ? 0:1))
+			(@length = bits.length).times { |i|
+				if bits[i] != 0
+					@str[i/8] = @str[i/8] | (1 << i%8)
+				end
+			}
+			self.__ba_sync_init__()
+		elsif bits.kind_of? BitArr
+			initialize(bits.str, length)
+		elsif bits.kind_of? Integer
+			@str = ""
+			while bits > 0xff
+				@str << bits & 0xff
+				bits >>= 8
+			end
+			@length = @str.length * 8
+			if bits > 0
+				@str << bits
+				while bits > 0
+					@length += 1
+					bits >>= 1
+				end
+			end
+			self.__ba_sync_init__()
+		else
+			raise ArgumentError,
+				"Invalid bits argument: #{bits.inspect}"
+		end
+	end
+	
+	def push(bit)
+	  self.synchronize {
+		bit = bit & 1
+		if (ofs = @length % 8) == 0
+			@str << bit
+		else
+			@str[-1] = @str[-1] | (bit << ofs)
+		end
+		@length = @length + 1
+		self
+	  }
+	end
+	
+	alias_method :<<, :push
+	
+	def delete_at(idx)
+	  self.synchronize {
+		idx = -idx-1 if idx < 0
+		return nil if idx >= @length
+		byte_i, ofs = idx / 8, idx % 8
+		res = @str[byte_i][ofs]
+		@str[byte_i] = ( (@str[byte_i] & (0xff >> 8-ofs)) << 1 ) |
+			(@str[byte_i] & ((0xff << ofs+1) & 0xff))
+		for i in byte_i...@str.length-1
+			@str[i] = @str[i] >> 1 | ((@str[i+1] & 1) << 7)
+		end
+		if (@length = @length - 1) % 8 == 0
+			@str[-1] = "" 
+		else
+			@str[-1] = @str[-1] >> 1
+		end
+		res
+	  }
+	end
+	
+	def slice!(i, len=nil)
+	  self.synchronize {
+		if i.kind_of? Range
+			i, len = [i.first, i.last].min, (i.last - i.first).abs
+			len = len + 1 if !i.exclude_end?
+		elsif len == nil
+			return delete_at(i)
+		end
+		i = @length+i if i < 0
+		return nil if i >= @length || i < 0 || len < 1
+		res = self[i, len]
+		len = @length - i if i + len > @length
+		byte_i, ofs = i / 8, i % 8
+		if len <= 8 - ofs
+			@str[byte_i] = ((@str[byte_i] & (0xff >> 8-ofs))<<len) |
+			  (@str[byte_i] & ((0xff << ofs+len) & 0xff))
+			ofs = 8 - len
+		else
+			del_algn_bits_cnt = len - 8 + ofs
+			@str.slice!(byte_i+1, del_algn_bits_cnt / 8)
+			if del_algn_bits_cnt % 8 > 0
+				del_algn_bits_cnt = del_algn_bits_cnt % 8
+				dst_mask = (0xff >> 8-ofs)
+				push_bits = @str[byte_i+1] >> del_algn_bits_cnt
+				@str[byte_i] = (@str[byte_i] & dst_mask) |
+					((push_bits << ofs) & 0xff)
+				if ofs > del_algn_bits_cnt
+					byte_i = byte_i + 1
+					@str[byte_i] = push_bits >> 8-ofs
+				else
+					@str[byte_i+1] = ""
+				end
+				ofs = (ofs + 8-del_algn_bits_cnt) % 8
+				@str[byte_i] = @str[byte_i] << 8-ofs
+			end
+		end
+		for i in byte_i...@str.length-1
+			@str[i] = (@str[i] >> 8-ofs) |
+				((@str[i+1] << ofs) & 0xff)
+		end
+		if @length % 8 <= 8-ofs
+			@str[-1] = ""
+		else
+			@str[-1] = @str[-1] >> 8-ofs
+		end
+		@length = @length - len
+		res
+	  }
+	end
+	
+	def at(i)
+		i = @length+i if i < 0
+		return 0 if i >= @length || i < 0
+		@str[i/8][i%8]
+	end
+	
+	def [](i, len=nil)
+	  self.synchronize {
+		if !len
+			if i.kind_of?(Range)
+				if i.last >= i.first
+					return self[i.first, i.last - i.first +
+						(i.exclude_end? ? 0 : 1)]
+				else
+					is = i
+				end
+			elsif i.kind_of?(Array)
+				is = i
+			elsif i.kind_of?(Integer)
+				i = @length+i if i < 0
+				return 0 if i >= @length || i < 0
+				return @str[i / 8][i % 8]
+			else
+				raise ArgumentError, "Wrong single argument"
+			end
+		else
+			i = @length+i if i < 0
+			return nil if len < 0 || i >= @length || i < 0
+			return BitArr.new if len == 0
+			len = @length - i if i + len > @length
+			byte_i, ofs = i / 8, i % 8
+			if ofs == 0
+				res = @str[byte_i, len/8]
+				if len % 8 > 0
+					res << @str[byte_i + len/8]
+					res[-1] = res[-1] & (0xff >> (8-len%8))
+				end
+				return BitArr.new(res, len)
+			end
+			mask,res = 0xff>>8-ofs, "\0"*(len/8 + (len%8==0 ? 0:1))
+			i = -1
+			(len/8).times { |i|
+				res[i] = (@str[byte_i] >> ofs) |
+					((@str[byte_i+1] & mask) << (8 - ofs))
+				byte_i = byte_i + 1
+			}
+			if len % 8 != 0
+				res[i+1] = (@str[byte_i] >> ofs)
+				if ofs + len % 8 > 8
+					res[i+1] = res[i+1] |
+					  ((@str[byte_i+1] & mask) << (8 - ofs))
+				end
+				res[i+1] = res[i+1] & (0xff >> 8 - len % 8)
+			end
+			return BitArr.new(res, len)
+		end
+		res = BitArr.new
+		is.each { |i|
+			i = @length+i if i < 0
+			if i >= @length || i < 0
+				res.push(0)
+			else
+				res.push(@str[i / 8][i % 8])
+			end
+		}
+		res
+	  }
+	end
+	
+	def []=(i, rval, len=nil)
+	  self.synchronize {
+		rval, len = len, rval if len
+		rval = BitArr.new(rval) if rval.kind_of?(Array) ||
+			rval.kind_of?(String)
+		if !len
+			if i.kind_of? Range
+				return self[[i.first,i.last].min,
+					(i.last - i.first).abs +
+					(i.exclude_end? ? 0 : 1)] = rval
+			elsif i.kind_of? Array
+				is = i
+			elsif i.kind_of? Integer
+				if rval.kind_of?(BitArr)
+					return self.delete_at(i) if rval.empty?
+					return self[i,1] = rval
+				end
+				if rval == nil
+					return self.delete_at(i)
+				else
+					@str << "\0"*(i/8-@str.length+1) if
+						i/8 >= @str.length
+					@length = i + 1 if i+1 > @length
+					if rval == 0
+						return @str[i/8] = @str[i/8] &
+							( (1 << (i%8)) ^ 0xff )
+					else
+						return @str[i/8] = @str[i/8] |
+							(1 << (i%8))
+					end
+				end
+			else
+				raise ArgumentError, "Invalid single argument"
+			end
+		else
+			len = 0 if len < 0
+			return self.slice!(i, len) if rval == nil
+			rval = BitArr.new(rval) if rval.kind_of? Integer
+			if len > rval.length
+				self.slice!(i + rval.length, len - rval.length)
+				len = rval.length
+			elsif len < rval.length
+				j = i + len
+				ins_len, byte_i, ofs = rval.length-len, j/8, j%8
+				if ofs + ins_len <= 8
+					shl_cnt = ins_len
+				else
+					shl_cnt = (ins_len - 8 + ofs) % 8
+				end
+				@str << "\0" if @length % 8 + shl_cnt > 8
+				(@str.length - 1).downto(byte_i + 1) { |k|
+					@str[k] = ((@str[k]<<shl_cnt) & 0xff) |
+						(@str[k-1] >> 8-shl_cnt)
+				}
+				if ofs + ins_len <= 8
+					@str[byte_i] = (@str[byte_i] &
+					  (0xff >> 8-ofs)) |
+					  (((@str[byte_i] &
+					   ((0xff << ofs) & 0xff)) << ins_len) &
+					   0xff)
+				else
+					@str[byte_i] = @str[byte_i] &
+						(0xff >> 8-ofs)
+					@str[byte_i, 0] = "\0" *
+						((ins_len - 8 + ofs) / 8)
+				end
+				@length = @length + ins_len
+			end
+			byte_i, ofs = (i+len-1) / 8, (i+len-1) % 8
+			if i + len > @length
+				@str << "\0" * (byte_i + 1 - @str.length)
+				@length = i + len
+			end
+			if byte_i == i / 8
+				@str[byte_i] = (@str[byte_i] &
+					((0xff << ofs) & 0xff)) |
+					(@str[byte_i] & (0xff >> 8 - i % 8)) |
+					(rval.to_i << i % 8)
+			else
+				@str[byte_i] = (@str[byte_i] &
+					((0xff << ofs) & 0xff)) |
+						rval[-8+ofs-1, ofs].str[0]
+				byte_i, ofs = i / 8, i % 8
+				@str[byte_i] = (@str[byte_i] & (0xff>>8-ofs)) |
+					(rval[0..8-ofs].to_i << ofs)
+				ofs = 8 - ofs
+				bytes_cnt = (i + rval.length) / 8 - byte_i - 1
+				@str[i, bytes_cnt] = rval[ofs, 8 * bytes_cnt].
+					str if bytes_cnt > 0
+			end
+			return
+		end
+		[is.length, rval.length].min.times { |i|
+			self[is[i]] = rval[rval_i]
+		}
+		if is.length > rval.length
+			del_is = (is[rval.length...is.length]).sort!
+			prev_i, c = del_is.last, 1
+			del_is.reverse_each { |i|
+				next if i == prev_i
+				if i = prev_i-1
+					c = c + 1
+				else
+					self.slice!(prev_i,c)
+					c = 1
+				end
+				prev_i = i
+			}
+			self.slice!(prev_i, c)
+		end
+	  }
+	end
+	
+	def each
+	  self.synchronize {
+		@str.each_byte { |b|
+			8.times { |i| yield b[i] }
+		}
+	  }
+	end
+	
+	def empty?
+		@length == 0
+	end
+	
+	def to_s
+	  self.synchronize {
+		@str.unpack("b#{@length}")[0]
+	  }
+	end
+	
+	def to_i
+	  self.synchronize {
+		res = 0
+		shl_cnt = 0
+		@str.each_byte { |b|
+			res = res | (b << shl_cnt)
+			shl_cnt = shl_cnt + 8
+		}
+		res
+	  }
+	end
+	
+	def <=>(other)
+		if other.kind_of?(BitArr)
+			return @length <=> other.length if @length!=other.length
+			0.upto((@length-1)/8) { |i|
+				return leg if (leg=(@str[i]<=>other.str[i]))!=0
+			}
+			return 0
+		elsif other.kind_of?(String)
+			return (@length/8) <=> other.length if
+				@length/8 != other.length
+			for i in 0.upto((@length-1)/8)
+				return leg if (leg = (@str[i] <=> other[i]))!=0
+			end
+			return 0
+		elsif other.kind_of?(Array)
+			return @length <=> other.length if @length!=other.length
+			for i in 0..@length
+				return leg if (leg = (self[i]<=>other[i])) != 0
+			end
+			return 0
+		elsif other.kind_of?(Integer)
+			return self.to_i <=> other
+		end
+	end
+end
+
+class IntBitPlaneArr
+	attr_reader :length, :bit_planes_cnt, :bit_arr
+	
+	def initialize(bits="", length=nil, bit_planes_cnt=nil)
+		@bit_arr = BitArr.new(bits, length)
+		if bit_planes_cnt
+			@bit_planes_cnt = bit_planes_cnt
+			@length = @bit_arr.length * @bit_planes_cnt
+		else
+			if (@length = @bit_arr.length) == 0
+				@bit_planes_cnt = 0
+			else
+				@bit_planes_cnt = 1
+			end
+		end
+	end
+	
+	def at(i)
+		i = @length+i if i < 0
+		return nil if i >= @length || i < 0
+		lm = 0
+		bp_start = 0
+		for p in 0...@bit_planes_cnt
+			lm |= (@bit_arr.at(bp_start + i) << p)
+			bp_start += @length
+		end
+		lm
+	end
+	
+	def at?(i, val)
+		i = @length+i if i < 0
+		return val == nil if i >= @length || i < 0
+		bp_start = 0
+		for p in 0...@bit_planes_cnt
+			return false if (val & 1) != @bit_arr[bp_start + i]
+			bp_start += @length
+			val >>= 1
+		end
+		return val == 0
+	end
+	
+	def bit_planes_cnt=(val)
+		@bit_planes_cnt = val
+		if val < @bit_planes_cnt
+			@bit_arr[@length*@bit_planes_cnt...@bit_arr.length]=nil
+		end
+	end
+	
+	def [](i, len=nil)
+		if len
+			is = i...(i+len)
+		else
+			if i.kind_of?(Range) || i.kind_of?(Array)
+				is = i
+			elsif i.kind_of?(Integer)
+				return self.at(i)
+			else
+				raise ArgumentError,
+					"Invalid index: #{i.inspect}"
+			end
+		end
+		is.collect { |i| self.at(i) }
+	end
+	
+	def []=(i, *args)
+		if args.length == 1
+			rval = args[0]
+			raise NotImplementError, "rval=nil" if !rval
+			raise NotImplementError, "i>length" if i>@length
+			rval = [rval] if rval.kind_of?(Integer)
+			if i.kind_of?(Range) || i.kind_of?(Array)
+				is = i
+			elsif i.kind_of?(Integer)
+				i = @length+i if i < 0
+				bp_start = 0
+				for p in 0...@bit_planes_cnt
+					bits = []
+					rval.each_with_index { |v, idx|
+						bits << (v&1)
+						rval[idx] >>= 1
+					}
+					@bit_arr[bp_start+i] = bits
+					bp_start += @length
+				end
+				not_all_0 = false
+				for v in rval
+					if v != 0
+						not_all_0 = true
+						break
+					end
+				end
+				while not_all_0
+					not_all_0 = false
+					bits = []
+					rval.each_with_index { |v, idx|
+						bits << (v&1)
+						rval[idx] >>= 1
+						not_all_0=true if rval[idx]!= 0
+					}
+					@bit_arr[bp_start+i] = bits
+					bp_start += @length
+					@bit_planes_cnt += 1
+				end
+				return
+			else
+				raise ArgumentError,
+					"Invalid index: #{i.inspect}"
+			end
+		elsif args.length == 2
+			len, rval = *args
+			is = i...(i+len)
+		else
+			raise ArgumentError,
+				"Invalid number of arguments: #{args.inspect}"
+		end
+		is.each_with_index { |i, idx|
+			self[i] = rval[idx]
+		}
+	end
+end
+
+class StringBitsObserver
+	def self.update(str, meth, args, block)
+		str.kill_bits
+	end
+end
+
+class String
+	def bits
+		self.add_observer(StringBitsObserver)
+		def bits
+			@bits = BitArr.new(self) unless @bits
+			@bits
+		end
+		self.bits
+	end
+	
+	def kill_bits
+		@bits = nil
+	end
+end