maruku 0.5.5 → 0.5.6

data/lib/maruku/ext/diagrams/grid.rb

@@ -1,78 +0,0 @@
-module Diagrams
-
-class Grid
-	attr_accessor :width, :height
-	
-	def initialize(width, height, init)
-		@width, @height =  width, height
-		@data = Array.new
-		height.times do @data.push [init]*@width end
-		@init = init
-	end
-	
-	def get(x, y)
-		@data[y][x]
-	end
-	
-	def set(x, y, v)
-		@data[y][x] = v || @init
-	end
-	
-	def inspect
-		@data.map{|x| 
-			x.map{|y| 
-				case y
-				when true;  '#'
-				when false, nil; ' '
-				when Fixnum; y.chr
-				end
-			}.join
-		}.join("\n")
-	end
-
-	def inspect2(valid)
-		s = ""
-		
-		s += "+" + "-"*@width + "+\n"
-		for y in 0..(@height-1)
-			s += "|"
-			for x in 0..(@width-1)
-				s += valid.get(x,y) ? get(x,y).chr : " "
-			end
-			s += "|"
-			s += "\n"
-		end
-		s += "+" + "-"*@width + "+\n"
-		s
-	end
-		
-	def each
-		for y in 0..(height-1)
-			for x in 0..(width-1)
-				e = get(x,y)
-				yield x,y,e
-			end
-		end
-	end
-	
-	def set_area(x,y,w,h,e)
-		for i in (x..x+w-1)
-			for j in (y..y+h-1)
-				set(i,j,e)
-			end
-		end
-	end
-	
-	def read_area(x,y,w,h)
-		s = ""
-		for j in (y..y+h-1)
-			for i in (x..x+w-1)
-				s << get(i,j)
-			end
-			s << "\n"
-		end
-		s
-	end
-end
-
-end

data/lib/maruku/ext/diagrams/inspect.rb

@@ -1,11 +0,0 @@
-module Diagrams
-	
-class Arrow
-	def inspect
-		"Arrow (#{(@cap1||?-).chr},#{(@cap2||?-).chr}) "+
-		"from #{@start_link.class} to #{@end_link.class} "+
-		" #{@start_pos.inspect} -> #{@end_pos.inspect}"
-	end
-end
-
-end

data/lib/maruku/ext/diagrams/layout.rb

@@ -1,508 +0,0 @@
-require 'set'
-
-module Diagrams
-	
-	class SSimple 
-		attr_accessor :begin, :end # begin and end variables
-		attr_accessor :spring
-		def get_spring() @spring end
-		def internal_variables() [] end
-	end
-	
-	class SParallel
-		attr_accessor :begin, :end # begin and end variables
-		attr_accessor :children
-		def internal_variables() 
-			@children.map{|x|x.internal_variables}.flatten
-		end		
-	end
-		
-		
-	class VarGraph
-		class Node
-			attr_accessor :name
-			attr_accessor :children
-			attr_accessor :parents 
-			
-			attr_accessor :next # closure of children
-			attr_accessor :prev # closure of parents
-			
-			def initialize(name_) 
-				@name = name_
-				@children = []
-				@parents = []
-				@next = []
-				@prev = []
-			end
-			
-			def inspect() "N[#{@name}]" end
-			alias to_s inspect
-			
-			# return parents
-			def compute_parents_closure
-				@parents.each do |parent| # xxx rifare
-					parent.compute_parents_closure 
-				end
-			
-				@prev = @parents.map do |p| p.prev end.flatten
-				@prev += @parents
-				@prev.uniq!
-			end
-			
-			def compute_children_closure
-				@children.each do |child| # xxx rifare
-					child.compute_children_closure 
-				end
-			
-				@next = @children.map do |c| c.next end.flatten
-				@next += @children
-				@next.uniq!
-			end
-			
-			def dist_up() @parents.empty? ? 0 : @parents.map{|x| x.dist_up}.max+1 end
-			def dist_down() @children.empty? ? 0 : @children.map{|x| x.dist_down}.max+1 end
-			
-		end
-		
-		def ==(other)
-			self.name == other.name
-		end
-		
-		attr_accessor :name2node
-		
-		def initialize 
-			self.name2node = {}
-		end
-		
-		def add_edge(var1, var2)
-			raise "var1 = var2 = #{var1.inspect}" if var1 == var2
-			
-			name2node[var1] = Node.new(var1) if not name2node.has_key? var1
-			name2node[var2] = Node.new(var2) if not name2node.has_key? var2
-			
-			n1,n2 = name2node[var1],name2node[var2]
-
-			n1.children.push n2
-			n2.parents.push n1
-		end
-		
-		def compute_closure
-			@name2node.each do |var, node|
-				node.compute_children_closure
-				node.compute_parents_closure
-			end
-			
-			@name2node.each do |var, node|
-#				puts "Node #{var} -> #{node.next.inspect}"
-#				puts "Node #{var} <- #{node.prev.inspect}"
-			end
-		end
-		
-		def go_recursive(node_head, id)
-			sub = []
-			node_head.children.each do |child|
-				if child.parents.size == 1
-					sub.push child
-				end
-			end
-
-			puts "#{id} Found #{sub.size} subs: #{sub.inspect}"
-
-			node_head.children.each do |child|
-				if (not sub.include?(child)) and child.parents.size != 1
-					adottare = []
-					sub.each do |su|
-						if child.prev.include? su
-							adottare.push su
-						end
-					end
-					
-					puts "#{id} child #{child} might be associated with #{adottare.inspect} - #{child.parents.inspect}"
-					
-				end
-			end
-			
-			sub.each_with_index do |sub, i|
-				puts "#{id}/#{i}: #{sub}"
-				go_recursive(sub, "#{id}/#{i}")
-			end
-		end
-		
-		def go!
-			
-			def do_it(name2node, function)
-				dist2nodes = []
-				name2node.each do |var, node|
-					dist = node.send function
-					dist2nodes[dist] =[] if dist2nodes[dist] == nil
-					dist2nodes[dist].push node	
-				end
-				dist2nodes
-			end
-
-			up = do_it(@name2node, :dist_up)
-			down = do_it(@name2node, :dist_down)
-
-			up.each_with_index do  |nodes, i|
-				puts "U Generation #{i}: #{nodes.inspect}"
-			end
-			down.each_with_index do  |nodes, i|
-				puts "D Generation #{i}: #{nodes.inspect}"
-			end
-			
-#			go_recursive(@name2node[DIAG_TL], "root")
-		end
-	end
-	
-	class Layout
-		def initialize
-			@hsystem = VarGraph.new
-			@vsystem = VarGraph.new
-			
-			@hlink,@vlink = {},{}
-			@hsprings,@vsprings={},{}
-		end
-		
-		def to_dot()
-			return to_dot_links(@hlink,@hsprings), to_dot_links(@vlink,@vsprings)
-		end
-		
-		def to_dot_links(links, springs)
-			s = "digraph diagram {\n"
-			links.each do |var, to_other|
-				if not to_other.empty?
-					var_ = var.gsub(/^[^_]+_/,'')
-					s += "\t#{var} [label = \"#{var_}\" ];\n"
-					to_other.each do |v2, spring|
-						s += "\t #{var} -> #{v2} [ label = \"#{spring.inspect}\"];\n"
-					end
-				end
-			end
-			s += "}\n"
-		end
-		
-		def add_var(s)
-			@hlink[s]=[] if not @hlink[s]
-			@vlink[s]=[] if not @vlink[s]
-		end
-		
-		# var2-var1 = spring
-		def add_con_h(var1,var2,hspring)
-			add_var var1; add_var var2;
-			@hlink[var1].push [var2, hspring]
-			@hsprings[[var1,var2]] = hspring
-
-			@hsystem.add_edge(var1, var2)
-		end
-		
-		def add_con_v(var1,var2,vspring)
-			add_var var1; add_var var2;
-			@vlink[var1].push [var2, vspring]
-			@vsprings[[var1,var2]] = vspring
-			
-			@vsystem.add_edge(var1, var2)
-		end
-		
-		def get_preferred(var1, var2)
-			hpaths = rec_paths(@hlink, var1, var2)
-			vpaths = rec_paths(@vlink, var1, var2)
-			puts inspect
-			hpaths.each do |h|
-				puts "H: #{h.inspect}"
-			end
-			vpaths.each do |v|
-				puts "V: #{v.inspect}"
-			end
-			
-			hsprings = 
-			hpaths.map do |h|
-				ss = []
-				for i in 0..(h.size-2)
-					v1,v2 = h[i],h[i+1]
-					ss.push  @hsprings[[v1,v2]]
-				end
-				ss
-			end
-			vsprings = 
-			vpaths.map do |h|
-				ss = []
-				for i in 0..(h.size-2)
-					v1,v2 = h[i],h[i+1]
-					ss.push  @vsprings[[v1,v2]]
-				end
-				ss
-			end
-			
-			
-			def go_up_parallel(par)
-				final = par[0]
-				for i in 1..(par.size-1)
-					final = Spring.parallel(final, par[i])
-				end
-				final
-			end
-			
-			def go_up_series(series)
-				tot = series[0]
-				for i in 1..(series.size-1)
-					tot = Spring.series(tot, series[i])
-				end
-				tot
-			end
-			
-			def compress(x)
-				t = x.map do |s| go_up_series(s) end
-				final = go_up_parallel(t)
-			end
-			
-			def sum_of_shrink(series)
-				sum = 0
-				series.each do |s| sum += s.shrink end 
-				sum
-			end
-			
-			def sum_of_stretch(series)
-				sum = 0
-				series.each do |s| sum += s.stretch  end
-				sum
-			end
-			
-			def go_back(imposed, series)
-				pref = go_up_series(series)
-				if pref.pref > imposed
-					# must shrink
-					shrink = pref.pref - imposed
-					sum = sum_of_shrink(series)
-					series.each do |s|
-						its_shrink = (s.shrink / sum) * shrink
-						its_imposed = s.pref - its_shrink
-						if s.imposed
-							s.imposed = (its_imposed+ s.imposed)*0.5
-						else
-							s.imposed = its_imposed
-						end
-						s.pref = s.pref*0.5 + s.imposed*0.5
-					end
-				else
-					# must stretch
-					stretch = imposed - pref.pref 
-					sum = sum_of_stretch(series)
-					series.each do |s|
-						its_stretch = (s.stretch / sum) * stretch
-						its_imposed = s.pref + its_stretch
-						if s.imposed
-							s.imposed = (its_imposed+ s.imposed)*0.5
-						else
-							s.imposed = its_imposed
-						end
-						s.pref = s.pref*0.5 + s.imposed*0.5
-					end
-				end
-			end
-			
-			for i in 0..100
-				hpref = compress(hsprings)
-				vpref = compress(vsprings)
-		
-				width = hpref.pref
-				height = vpref.pref
-			
-				hsprings.each do |series| go_back(height, series) end
-				vsprings.each do |series| go_back(width, series) end
-			end
-
-			hpaths.each do |h|
-				ss = []
-				len = 0
-				for i in 0..(h.size-2)
-					v1,v2 = h[i],h[i+1]
-					this = @hsprings[[v1,v2]].imposed
-					puts "#{v1} - #{v2}   | "+  ("%0.2f" % this)
-					len += this
-				end
-				puts "LEN: #{len}"
-				ss
-			end
-			
-			return hpref,vpref
-		end
-		
-		# returns [] if there isn't one
-		def rec_paths(links, var1, var2)
-			all_paths = []
-			(links[var1] || []).each do |v, spring|
-				if v == var2
-					all_paths.push [var2]
-				else
-					all_paths = all_paths + rec_paths(links, v, var2)
-				end
-			end
-			all_paths.map{|x| [var1]+x}
-		end
-	
-	
-		def algo2 
-			@hsystem.compute_closure
-			@hsystem.go!
-=begin			
-			def reduce(links, varA, varZ)
-				paths = rec_paths(links, varA, varZ)
-				
-				puts "Found #{paths.size} paths:"
-				paths.each_with_index do |path, i|
-					puts "path #{i}: #{path.inspect}"
-				end
-				
-				var2path = {}
-				
-				paths.each_with_index do |path, p|
-					for i in 1..path.size-2
-						var = path[i]
-						var2path[var] ||= []
-						var2path[var].push p
-					end
-				end
-				
-				var2path.each do |v, paths|
-					puts "var #{v} -> #{paths.inspect}"
-				end
-			end
-			
-			reduce(@hlink, DIAG_TL, DIAG_BR)
-=end
-			
-		end
-		
-		def inspect
-			s = ""
-			@hlink.each do |v1,a|
-				a.each do |v2, spring|
-					s += "#{v1.inspect} -> #{v2.inspect} (#{spring.inspect})\n"
-				end
-			end
-			s
-		end
-	end
-
-	DIAG_TL = "tl"
-	DIAG_BR = "br"
-	
-	class Diagram
-		
-
-		def top_right(i); "#{@diag_id}_b#{i}_tr"; end
-		
-		def assign_variables(diag_id)
-			@boxes.each_with_index do |b, i|
-				b.v_tl = "#{diag_id}_b#{i}_tl"
-				b.v_br = "#{diag_id}_b#{i}_br"
-			end
-			@arrows.each_with_index do |a, i| 
-				a.v_start = "#{diag_id}_a#{i}_start"
-				a.v_end = "#{diag_id}_a#{i}_end"
-			end
-			@points.each_with_index do |p, i| 
-				p.v_p = "#{diag_id}_p#{i}_p"
-			end
-		end
-		
-		def do_layout(diag_id)
-			def margin_con() Spring.new(30,0,30,1,1000)   end
-			def arrow_con()  Spring.new(30,1,60,100,1000) end
-			def zero_con()   Spring.new(0,0,0,0,0)     end
-			def positive_con(pref)   Spring.new(0,1,pref,1000,1000)     end
-			
-			@diag_id = diag_id
-			assign_variables(diag_id)
-			
-			l = Layout.new
-			@boxes.each  do |b|
-				# size of the box is copied from b.hs and b.vs
-				l.add_con_h(b.v_tl, b.v_br, b.hs)
-				l.add_con_v(b.v_tl, b.v_br, b.vs)
-				# should not be outside of the diagram
-				l.add_con_h(DIAG_TL,  b.v_tl, margin_con)
-				l.add_con_h(b.v_br, DIAG_BR, margin_con)
-				l.add_con_v(DIAG_TL,  b.v_tl, margin_con)
-				l.add_con_v(b.v_br, DIAG_BR, margin_con)
-				# now, for each arrow 
-				b.links[:N].each{|a|
-					l.add_con_v(a.v_end, b.v_tl, zero_con)
-					l.add_con_h(b.v_tl, a.v_end, positive_con(b.hs.pref/2))
-					l.add_con_h(a.v_end, b.v_br, positive_con(b.hs.pref/2))
-				}
-				b.links[:S].each{|a|
-					l.add_con_v(b.v_br, a.v_start, zero_con)
-					l.add_con_h(b.v_tl, a.v_start, positive_con(b.hs.pref/2))
-					l.add_con_h(a.v_start, b.v_br, positive_con(b.hs.pref/2))
-				}
-				b.links[:W].each{|a|
-					l.add_con_h(a.v_end, b.v_tl, zero_con) 
-					l.add_con_v(b.v_tl, a.v_end, positive_con(b.vs.pref/2))
-					l.add_con_v(a.v_end, b.v_br, positive_con(b.vs.pref/2))
-				}
-				b.links[:E].each{|a|
-					l.add_con_h(b.v_br, a.v_start, zero_con)
-					l.add_con_v(b.v_tl, a.v_start, positive_con(b.vs.pref/2))
-					l.add_con_v(a.v_start, b.v_br, positive_con(b.vs.pref/2))
-				}
-				
-				b.aligned[:t].each do |b2| l.add_con_v(b2.v_tl, b.v_tl, zero_con) end
-				b.aligned[:b].each do |b2| l.add_con_v(b2.v_br, b.v_br, zero_con) end
-				b.aligned[:l].each do |b2| l.add_con_h(b2.v_tl, b.v_tl, zero_con) end
-				b.aligned[:r].each do |b2| l.add_con_h(b2.v_br, b.v_br, zero_con) end
-			end
-			
-			@points.each do |p|
-				# should not be outside of the diagram
-				l.add_con_h(DIAG_TL,  p.v_p, margin_con)
-				l.add_con_h(p.v_p, DIAG_BR, margin_con)
-				l.add_con_v(DIAG_TL,  p.v_p, margin_con)
-				l.add_con_v(p.v_p, DIAG_BR, margin_con)
-				# now, for each arrow 
-				p.links[:N].each{|a|
-					l.add_con_v(a.v_end, p.v_p, zero_con)
-						l.add_con_h(a.v_end, p.v_p, zero_con)
-				}
-				p.links[:S].each{|a|
-					l.add_con_v(p.v_p, a.v_start, zero_con)
-						l.add_con_h(p.v_p, a.v_start, zero_con)
-				}
-				p.links[:W].each{|a|
-					l.add_con_h(a.v_end, p.v_p, zero_con)
-						l.add_con_v(a.v_end, p.v_p, zero_con)
-				}
-				p.links[:E].each{|a|
-					l.add_con_h(p.v_p, a.v_start, zero_con)
-						l.add_con_v(p.v_p, a.v_start, zero_con)
-				}
-
-				p.aligned[:t].each do |p2| l.add_con_v(p2.v_p, p.v_p, zero_con) end
-				p.aligned[:l].each do |p2| l.add_con_h(p2.v_p, p.v_p, zero_con) end
-			end
-			
-			@arrows.each do |a|
-				if a.is_vert?
-					l.add_con_v(a.v_start, a.v_end, arrow_con)
-					l.add_con_h(a.v_start, a.v_end, zero_con)
-				else
-					l.add_con_h(a.v_start, a.v_end, arrow_con)
-					l.add_con_v(a.v_start, a.v_end, zero_con)
-				end
-			end
-
-			doth, dotv = l.to_dot
-			File.open("#{diag_id}_h.dot",'w') do |f| f.write doth end
-			File.open("#{diag_id}_v.dot",'w') do |f| f.write dotv end
-
-			l.algo2
-#			hs, vs = l.get_preferred(DIAG_TL, DIAG_BR)
-			
-#			puts "Preferred hs = #{hs.inspect}"
-#			puts "Preferred vs = #{vs.inspect}"
-		end
-		
-	end
-	
-	
-end