yargi 0.1.2 → 0.2.0

data/lib/yargi/loader.rb

@@ -0,0 +1 @@
+

data/lib/yargi/markable.rb

@@ -1,10 +1,10 @@
 module Yargi
-  
+
   #
-  # Allows users to put its own marks on graph elements. A Hash-like API for setting 
-  # and getting these marks is provided through <tt>[]</tt> and <tt>[]=</tt>. When a 
-  # Symbol object is used as a mark key (and provided it does'nt lead to a name 
-  # collision), accessors are automatically defined as singleton methods (without 
+  # Allows users to put its own marks on graph elements. A Hash-like API for setting
+  # and getting these marks is provided through <tt>[]</tt> and <tt>[]=</tt>. When a
+  # Symbol object is used as a mark key (and provided it does'nt lead to a name
+  # collision), accessors are automatically defined as singleton methods (without
   # creating an instance variable however).
   #
   module Markable
@@ -13,7 +13,7 @@ module Yargi
     def tag(*modules)
       modules.each {|mod| self.extend(mod)}
     end
-    
+
     # Checks if a given mark exists
     def has_mark?(key)
       @marks and @marks.has_key?(key)
@@ -21,10 +21,10 @@ module Yargi
 
     # Returns the mark value installed under _key_. Returns nil if no such mark.
     def get_mark(key)
-      @marks ? @marks[key] : nil; 
+      @marks ? @marks[key] : nil;
     end
     alias :[] :get_mark
-    
+
     # Sets a key/value pair as a mark. Overrides previous mark value if _key_ is
     # already in used. Automatically creates accessors if _key_ is a Symbol and such
     # methods do not already exists.
@@ -41,7 +41,7 @@ module Yargi
       end
     end
     alias :[]= :set_mark
-    
+
     # Add all marks provided by a Hash instance _marks_.
     def add_marks(marks=nil)
       marks.each_pair {|k,v| self[k]=v} if marks
@@ -51,7 +51,7 @@ module Yargi
       end
     end
     alias :merge_marks :add_marks
-    
+
     # Converts this Markable to a Hash. When _nonil_ is true, nil mark values
     # do not lead to hash entries.
     def to_h(nonil=true)
@@ -62,7 +62,7 @@ module Yargi
       end
       marks
     end
-    
+
   end # module Markable
-  
+
 end

data/lib/yargi/predicate.rb

@@ -1,5 +1,5 @@
 module Yargi
-  
+
   #
   # Predicate for graph elements.
   #
@@ -13,7 +13,7 @@ module Yargi
   # [otherwise] an ArgumentError is raised.
   #
   class Predicate
-    
+
     class << self
       # Builds a 'what and block' predicate, according the automatic conversions
       # descibed above.
@@ -30,6 +30,8 @@ module Yargi
             ALL
           when FalseClass
             NONE
+          when Integer
+            IndexPredicate.new(what)
           else
             raise ArgumentError, "Unable to convert #{what} to a predicate"
         end
@@ -40,136 +42,136 @@ module Yargi
         end
       end
     end
-  
+
     # Builds a 'self and right' predicate
     def &(right)
       AndPredicate.new(*[self, Predicate.to_predicate(right)])
     end
-    
+
     # Builds a 'self or right' predicate
     def |(right)
       OrPredicate.new(*[self, Predicate.to_predicate(right)])
     end
-    
+
     # Builds a 'not(self)' predicate
     def not()
       NotPredicate.new(self)
     end
-    
+
   end # class Predicate
 
   # Decorates _true_ as a predicate
   class TruePredicate < Predicate
-    
+
     # Always returns true
     def ===(elm)
       true
     end
-    
+
     # Returns 'true'
     def inspect
       "true"
     end
-    
+
   end # class TruePredicate
 
   # Decorates _false_ as a predicate
   class FalsePredicate < Predicate
-    
+
     # Always returns false
     def ===(elm)
       false
     end
-    
+
     # Returns 'false'
     def inspect
       "false"
     end
-    
+
   end # class TruePredicate
 
   # Decorates a module instance as a predicate
   class TagPredicate < Predicate
-    
+
     # Creates a Tag predicate
     def initialize(mod)
       raise ArgumentError, "Module expected, #{mod} received" unless Module===mod
       @mod = mod
     end
-    
+
     # Predicate implementation
     def ===(elm)
       @mod===elm
     end
-    
+
     # Helps debugging predicates
     def inspect
       "is_a?(#{@mod})"
     end
-    
+
   end # class TagPredicate
-  
+
   # Decorates a block as a predicate
   class LambdaPredicate < Predicate
-    
+
     # Creates a Tag predicate
     def initialize(&block)
       raise ArgumentError, "Block of arity 1 expected" unless (block and block.arity==1)
       @block = block
     end
-    
+
     # Predicate implementation
     def ===(elm)
       @block.call(elm)
     end
-    
+
     # Helps debugging predicates
     def inspect
       "lambda{...}"
     end
-    
+
   end # class LambdaPredicate
-  
+
   # Negates another predicate
   class NotPredicate < Predicate
-    
+
     # Creates a 'not(negated)' predicate
     def initialize(negated)
       @negated = Predicate.to_predicate(negated)
     end
-    
+
     # Predicate implementation
     def ===(elm)
       not(@negated === elm)
     end
-    
+
     # Helps debugging predicates
     def inspect
       "not(#{@negated})"
     end
-    
+
   end # class NotPredicate
-  
+
   # Conjunction predicate
   class AndPredicate < Predicate
-    
+
     # Builds a AND predicate
     def initialize(*anded)
       raise ArgumentError, "Predicates expected" unless anded.all?{|p| Predicate===p}
       @anded = anded
     end
-    
+
     # Predicate implementation
     def ===(elm)
       @anded.all?{|p| p===elm}
     end
-    
+
     # Pushes _right_ in the anded array
     def &(right)
       @anded << Predicate.to_predicate(right)
       self
     end
-    
+
     # Helps debugging predicates
     def inspect
       @anded.inject('') do |memo,p|
@@ -180,29 +182,29 @@ module Yargi
         end
       end
     end
-    
+
   end # class AndPredicate
-  
+
   # Disjunction predicate
   class OrPredicate < Predicate
-    
+
     # Builds a OR predicate
     def initialize(*ored)
       raise ArgumentError, "Predicates expected" unless ored.all?{|p| Predicate===p}
       @ored = ored
     end
-    
+
     # Predicate implementation
     def ===(elm)
       @ored.any?{|p| p===elm}
     end
-    
+
     # Pushes _right_ in the ored array
     def |(right)
       @ored << Predicate.to_predicate(right)
       self
     end
-    
+
     # Helps debugging predicates
     def inspect
       @ored.inject('') do |memo,p|
@@ -213,17 +215,34 @@ module Yargi
         end
       end
     end
-    
+
   end # class OrPredicate
-  
+
+  # Index predicate
+  class IndexPredicate < Predicate
+
+    def initialize(index)
+      @index = index
+    end
+
+    def ===(elm)
+      elm.index == @index
+    end
+
+    def inspect
+      "elm.index == #{index}"
+    end
+
+  end # class IndexPredicate
+
   class Predicate
-    
+
     # Predicates that always return true
     ALL = TruePredicate.new
-  
+
     # Predicates that always return false
     NONE = FalsePredicate.new
-  
+
   end # class Predicate
-  
+
 end

data/lib/yargi/random.rb

@@ -0,0 +1,98 @@
+module Yargi
+
+  #
+  # Random graph generator
+  #
+  class Random
+
+    # @return [Integer] number of vertices to generate
+    attr_accessor :vertex_count
+
+    # @return [Proc] proc to call on vertex generation
+    attr_accessor :vertex_builder
+
+    # @return [Integer] number of edges to generate
+    attr_accessor :edge_count
+
+    # @return [Proc] proc to call on vertex generation
+    attr_accessor :edge_builder
+
+    # @returns [Boolean] strip the generated graph to one connex component
+    #          reachable from the first vertex?
+    attr_accessor :strip
+
+    # Creates an algorithm instance
+    def initialize
+      @vertex_count = 50
+      @vertex_builder = nil
+      @edge_count = 150
+      @edge_builder = nil
+      @strip = true
+      yield(self) if block_given?
+    end
+
+    # Executes the random generation
+    def execute
+      graph = Digraph.new{|g|
+        vertex_count.times do |i|
+          vertex = g.add_vertex
+          vertex_builder.call(vertex,i) if vertex_builder
+        end
+        edge_count.times do |i|
+          source = g.ith_vertex(Kernel.rand(vertex_count))
+          target = g.ith_vertex(Kernel.rand(vertex_count))
+          edge = g.connect(source, target)
+          edge_builder.call(edge,i) if edge_builder
+        end
+      }
+      strip ? _strip(graph) : graph
+    end
+
+    protected
+
+    def _strip(graph)
+      Decorate::DEPTH.execute(graph)
+      graph.remove_vertices graph.vertices{|v| v[:depth] == 1.0/0}
+      graph
+    end
+
+  end # class Random
+
+  class Digraph
+
+    #
+    # Generates a random graph.
+    #
+    # @param [Integer] vertex_count number of vertices to generate
+    # @param [Integer] edge_count number of edges to generate
+    # @param [Integer] strip strip the graph (reachability for first vertex)
+    # @return [Digraph] a directed graph randomly generated
+    #
+    # Example:
+    #
+    #     # Generate a random graph with 20 vertices
+    #     # and 60 edges exactly (no stripping)
+    #     Digraph.random(20,60,false)
+    #
+    #     # Even more powerful, r is a Digraph::Random
+    #     Digraph.random do |r|
+    #       r.vertex_count = 20
+    #       r.edge_count = 60
+    #       r.strip = false
+    #       r.vertex_builder = lambda{|v,i| ... } # as digraph.add_n_vertices
+    #       r.edge_builder   = lambda{|e,i| ... } # similarl
+    #     end
+    #
+    def self.random(vertex_count = nil, edge_count = nil, strip = nil)
+      r = Random.new{|rand|
+        rand.vertex_count = vertex_count if vertex_count
+        rand.edge_count = edge_count if edge_count
+        rand.strip = strip if strip
+      }
+      yield(r) if block_given?
+      r.execute
+    end
+
+  end
+
+end # module Yargi

data/lib/yargi/version.rb

@@ -0,0 +1,14 @@
+module Yargi
+  module Version
+
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    def self.to_s
+      [ MAJOR, MINOR, TINY ].join('.')
+    end
+
+  end
+  VERSION = Version.to_s
+end

data/lib/yargi/vertex_set.rb

@@ -1,30 +1,30 @@
 module Yargi
-  
+
   # A set of vertices
   class VertexSet < ElementSet
-    
+
     ### Factory section #######################################################
-    
+
     # Creates a VertexSet instance using _elements_ varargs.
     def self.[](*elements)
       VertexSet.new(elements)
     end
-    
-    
+
+
     ### Walking section #######################################################
-    
+
     # Returns incoming edges of all vertices of this set
     def in_edges(filter=nil, &block)
       r = self.collect {|v| v.in_edges(filter, &block) }
       EdgeSet.new(r).flatten.uniq
     end
-    
+
     # Returns all back-adjacent vertices reachable from this set
     def in_adjacent(filter=nil, &block)
       r = self.collect {|v| v.in_adjacent(filter, &block) }
       VertexSet.new(r).flatten.uniq
     end
-    
+
     # Returns all outgoing edges of all vertices of this set
     def out_edges(filter=nil, &block)
       r = self.collect {|v| v.out_edges(filter, &block) }
@@ -36,16 +36,16 @@ module Yargi
       r = self.collect {|v| v.out_adjacent(filter, &block) }
       VertexSet.new(r).flatten.uniq
     end
-    
+
     # Returns all adjacent vertices reachable from this set
     def adjacent(filter=nil, &block)
       (in_adjacent(filter, &block)+out_adjacent(filter, &block)).uniq
     end
-    
-    
+
+
     ### Protected section #####################################################
     protected
-        
+
     # Extends with VertexSet instead of ElementSet
     def extend_result(result)
       VertexSet.new(result)