maruku 0.5.0 → 0.5.1

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

@@ -1,8 +1,410 @@
+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
-		DIAG_TL = "tl"
-		DIAG_BR = "br"
+		
+
+		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
@@ -93,6 +495,7 @@ module Diagrams
 			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}"

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

@@ -88,211 +88,6 @@ module Diagrams
 			s 
 		end
 		
-		class Layout
-			def initialize
-				@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
-			end
-			
-			def add_con_v(var1,var2,vspring)
-				add_var var1; add_var var2;
-				@vlink[var1].push [var2, vspring]
-				@vsprings[[var1,var2]] = vspring
-			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 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
-
-		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
 		
 		# in points 
 		def to_dev(x)