extract_curves 0.0.1-i586-linux

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

data/ruby_libs/pav/string/ext.rb

@@ -0,0 +1,58 @@
+class String
+	def starts_with(str)
+		self[0, str.length] == str
+	end
+	
+	def ends_with(str)
+		self[-str.length, str.length] == str
+	end
+	
+	def expand_tabs(tab_stop=8)
+		self.gsub(/([^\t]{#{tab_stop}})|([^\t]*)\t/n) {
+			[$+].pack("A#{tab_stop}") }
+	end
+	
+	def expand_tabs!(tab_stop=8)
+		self.gsub!(/([^\t]{#{tab_stop}})|([^\t]*)\t/n) {
+			[$+].pack("A#{tab_stop}") }
+	end
+	
+	def eval_backspace(bs="\b")
+		self.gsub(/([^#{bs}]*)(#{bs}+)/n) { $1[0, $1.length-$2.length] }
+	end
+	
+	def eval_backspace!(bs="\b")
+		self.gsub!(/([^#{bs}]*)(#{bs}+)/n){ $1[0, $1.length-$2.length] }
+	end
+	
+	def cap_first
+		return "" if self.length < 1
+		self[0,1].upcase + self[1, self.length-1]
+	end
+	
+	def downcase_first
+		return "" if self.length < 1
+		self[0,1].downcase + self[1, self.length-1]
+	end
+	
+	def ^(other)
+		res = self.dup
+		0.upto([self.length, other.length].min - 1) { |i|
+			res[i] ^= other[i]
+		}
+		res
+	end
+	
+	def xor!(mask_str)
+		0.upto([self.length, mask_str.length].min - 1) { |i|
+			self[i] ^= mask_str[i]
+		}
+		self
+	end
+	
+	def bits_to_i
+		res = 0
+		self.each_byte { |b| res = (res << 8) + b }
+		res
+	end
+end

data/ruby_libs/pav/string/observable.rb

@@ -0,0 +1,155 @@
+require 'observer'
+#require 'irb/frame'
+
+class PMethName
+
+# Is +name+ the name of a method that usually changes the object?
+def self.obj_changer?(name)
+	name[-1,1] == "!" ||
+	(name.length > 1 && name[-1,1] == "=" &&
+		!["=", ">", "<", "+", "-", "*", "/"].member?(name[-2,1])) ||
+	name == "<<"
+end
+
+end
+
+# If the only way to change a string is through the built-in string changing
+# functions, we don't need to be so dynamic.
+
+class String
+	include Observable
+	
+	alias_method :__add_observer_o__, :add_observer
+	
+	def wrap_changer_meth(id)
+		# if method wrapped in self's anonymous class:
+		if self.respond_to?("__pso_#{id.to_i}_o__")
+			return
+		end
+		eval <<-"end_eval"
+			class <<self
+				def #{id.id2name}(*args, &block)
+					tc = Thread::critical=(true)
+					begin
+						res= super(*args,&block)
+					ensure
+						Thread::critical = tc
+					end
+					self.changed(true)
+					self.notify_observers(self,
+					  #{id.id2name.inspect}, args,
+					  block)
+					res
+				end
+			end
+		end_eval
+	end
+	
+	def add_observer(obj)
+		tc = Thread::critical=(true)
+		if !self.respond_to?(:__add_observer_o__)
+			Thread::critical = tc
+			return self.add_observer(obj)
+		end
+		class <<self
+			@@__pso_adding_meth__ = false
+			alias_method :add_observer, :__add_observer_o__
+			private :__add_observer_o__
+#			if self.public_instance_methods.member? "extend_object"
+#				alias_method :__pso_extend_object_o__,
+#					:extend_object unless
+#					respond_to? :__pso_extend_object_o__
+#				def self.extend_object(id)
+#					Thread::critical =
+#						(tc = Thread::critical) || true
+#					if PMethName::obj_changer?(id.id2name)&&
+#					!@@__pso_adding_meth__
+#					  @@__pso_adding_meth__ = true
+#					  module_eval <<-"end_eval"
+#					    alias_method :__pso_#{id.to_i}_o__,
+#					    	#{id.inspect}
+#					    def #{id.id2name}(*args, &block)
+#						Thread::critical =
+#						 (tc = Thread::critical) || true
+#						begin
+#						  res = __pso_#{id.to_i}_o__(
+#						  	*args, &block)
+#						ensure
+#							Thread::critical = tc
+#						end
+#						self.changed(true)
+#						self.notify_observers(self,
+#							#{id.id2name.inspect},
+#							args, block)
+#						res
+#					    end
+#					  end_eval
+#					  @@__pso_adding_meth__ = false
+#					end
+#					Thread::critical = tc
+#					__pso_method_added_o__(id)
+#				end
+#			else
+#				def self.extend_object(id)
+#					Thread::critical =
+#						(tc = Thread::critical) || true
+#					if PMethName::obj_changer?(id.id2name)&&
+#					!@@__pso_adding_meth__
+#					  @@__pso_adding_meth__ = true
+#					  module_eval <<-"end_eval"
+#					    alias_method :__pso_#{id.to_i}_o__,
+#					    	#{id.inspect}
+#					    def #{id.id2name}(*args, &block)
+#						Thread::critical =
+#						 (tc = Thread::critical) || true
+#						begin
+#						  res = __pso_#{id.to_i}_o__(
+#						  	*args, &block)
+#						ensure
+#							Thread::critical = tc
+#						end
+#						self.changed(true)
+#						self.notify_observers(self,
+#							#{id.id2name.inspect},
+#							args, block)
+#						res
+#					    end
+#					  end_eval
+#					  @@__pso_adding_meth__ = false
+#					end
+#					Thread::critical = tc
+#				end
+#			end
+		end
+		for m in self.methods.delete_if{|m| !PMethName::obj_changer?(m)}
+			self.wrap_changer_meth(m.to_sym)
+		end
+		Thread::critical = tc
+		self.add_observer(obj)
+	end
+	
+#	if respond_to? :method_added
+#		alias_method :__pso_m_method_added_o__, :method_added unless
+#			respond_to? :__pso_m_method_added_o__
+#		def self.method_added(id)
+#			if PMethName.obj_changer?(id.id2name)
+#				ObjectSpace.each_object(self) { |o|
+#					if !o.respond_to? :__add_observer_o__
+#						o.wrap_changer_meth(id)
+#					end
+#				}
+#			end
+#			self.__pso_m_method_added_o__(id)
+#		end
+#	else
+#		def self.method_added(id)
+#			if PMethName.obj_changer?(id.id2name)
+#				ObjectSpace.each_object(self) { |o|
+#					if !o.respond_to? :__add_observer_o__
+#						o.wrap_changer_meth(id)
+#					end
+#				}
+#			end
+#		end
+#	end
+end