ogr 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83cf5471104a54bfb6ed4f87203f21af7b6c0dc1
-  data.tar.gz: ecf312736e5b4a2a950fed9157d563625ff2d266
+  metadata.gz: ffca6a82d71e20952e078e9805c5ad30bc1bdc73
+  data.tar.gz: 8c1e23fc9bfed9e0c4d798318bff2f8f23962307
 SHA512:
-  metadata.gz: 7c6a05934278805233e4a72479bd1aa6e1f8d172a25a5498da9c714acf61b9391723205d7a105a2910b87821408d3b9fc9c909ed1bb56fc2d72c23c463c7a5dc
-  data.tar.gz: 1c56b4b496bb8c60b237599c7c8d06597f5620fda246804f9b097114997ff1a4662b19d0d8e519252c750d6e9f3ddf51e3e2647cc09a6c00d0ecbfafc99253d3
+  metadata.gz: d22658bd055558b8678099d3188ac4cfa1dbc8c318fe9b0ca2cdb9d71c8ab436e88eeb4e23f5031cfae0750723188b5c4e37febfa84c40cc344ecb0c0222fff8
+  data.tar.gz: 34d97eeaaad02a14e25a129154e47ceefeca43c8af16525ec9fb6eb067660db59dc4ea3084a55eb5b26f5a50e7877001800be076d768968352f9a4c89b83ae42

data/.rubocop.yml

@@ -1,3 +1,5 @@
 Metrics/LineLength:
   Max: 100
 
+Lint/AssignmentInCondition:
+  Enabled: false

data/.travis.yml

@@ -1,10 +1,19 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.2.2
+  - 2.1.5
   - 2.2.3
   - 2.3.0
   - jruby-head
+env:
+  - BENCH=false
+  - BENCH=true
+matrix:
+  exclude:
+    rvm: jruby-head
+    env: BENCH=true
+  allow_failures:
+    - env: BENCH=true
 script:
   - bundle exec rake
 before_install:

data/README.md

@@ -1,6 +1,12 @@
 # Ogr
 
-General graph library for Ruby. Provides sparse(or dense), directed(or undirected) and weighted graphs for Ruby.
+[![Build Status](https://travis-ci.org/knife/ogr.svg?branch=master)](https://travis-ci.org/knife/ogr)
+[![Code Climate](https://codeclimate.com/github/knife/ogr/badges/gpa.svg)](https://codeclimate.com/github/knife/ogr)
+
+General graph library for Ruby. Provides sparse(or dense), directed(or undirected) and weighted(or normal) graphs. 
+Graph processing algorithms like BFS, DFS, ShortestPaths, MinimumSpanningTree are also included. 
+This gem depends only on [DS Gem](https://github.com/knife/ds) which contains other data structures
+not implemented in Ruby Standard Library.
 
 ## Installation
 
@@ -15,7 +21,7 @@ General graph library for Ruby. Provides sparse(or dense), directed(or undirecte
   graph = Ogr::Graph.new
 ```
 
-To not have to type "Ogr::" before each class, use:
+To not have to type "Ogr::" before each class:
 
 ```ruby
   include Ogr
@@ -25,47 +31,66 @@ To not have to type "Ogr::" before each class, use:
 
 ## Graph
 
-Creating new Graph
+Creating new Graph is easy.
 
-First define edges:
+First define edges(weights are optional):
 
 ```ruby
   edges = []
-  edges << Edge.new('Jim','Bob')
-  edges << Edge.new('Jim','Tom')
-  edges << Edge.new('Bob','Jack')
-  edges << Edge.new('Tom','Bob')
+  edges << Edge.new('Jim','Bob', 12)
+  edges << Edge.new('Jim','Tom', 3)
+  edges << Edge.new('Bob','Jack', 8)
+  edges << Edge.new('Tom','Bob', 5)
 ```
 or
 
 ```ruby
   edges = [
-      ['Jim','Bob'],
-      ['Jim','Tom'],
-      ['Bob','Jack'],
-      ['Tom','Bob']
+      ['Jim','Bob', 12],
+      ['Jim','Tom', 3],
+      ['Bob','Jack', 8],
+      ['Tom','Bob', 5]
   ]
 ```
 
-New undirected graph (implemented as adjency list)
+Next create new graph:
 
 ```ruby
   graph = Graph.new(edges)
 ```
 
-New undirected dense graph (implemented as triangular matrix)
+By default graphs are implemented as adjacency lists. This implementation works in most situations.
+However, sometimes triangular matrix may be better choice for internal graph representation (for e.g. dense graphs).
+You can set graph internal representation by passing second argument to initializer or using special constructor.
 
 ```ruby
-  graph = Graph.create(edges)
+  graph = Graph.new_dense(edges)
 ```
 or
 
 ```ruby
   graph = Graph.new(edges, :tri_matrix)
-
 ```
 
+
+### Graph API
+
+Some methods defined on graph object:
+
+* degree
+* edge?
+* add_edge
+* add_edges
+* get_edge
+* vertex_size
+* remove
+* add
+* neighbors
+* vertexes
+* edges
+
 Examples:
+
 ```ruby
   graph.vertex_size #=> 4
   graph.degree("Bob") #=> 3
@@ -74,19 +99,22 @@ Examples:
   graph.add_edge(Edge.new("Bob", "Kate"))
   graph.remove("Bob", "Jack")
   graph.neighbors('Tom') #=> ["Bob", "Jim"]
+  graph.add("Bob", "Jack")
 ```
 
-Iterating
+Iterators:
 
 ```ruby
-  graph.each_edge{ |e| p e }
-  graph.each_vertex{ |v| p v }
+  graph.each_edge { |e| p e }
+  graph.each_vertex { |v| p v }
 ```
 
 
 ## Digraph
 
-Directed Weighted Graph
+Digraph (Directed Graph) is graph with directed edges.
+
+Creating new directed graph (implemented as adjacency list):
 
 ```ruby
   edges = []
@@ -104,38 +132,94 @@ Directed Weighted Graph
   edges << Edge.new(:F, :B, 7)
 ```
 
-New directed graph (implemented as adjency list)
-
 ```ruby
-  wdigraph = Digraph.new(edges)
+  digraph = Digraph.new(edges)
 ```
 
-New directed dense graph (implemented as matrix)
+New directed dense graph (implemented as matrix):
 ```ruby
-  wdigraph = Digraph.create(edges)
+  digraph = Digraph.new_dense(edges)
 ```
 or
 ```ruby
-  wdigraph = Digraph.new(edges, :matrix)
+  digraph = Digraph.new(edges, :matrix)
 ```
 
+### Digraph API
+
+Digraph inherits from Graph so all methods defined in Graph are available.
+Digraph defines some additional methods specific to directed graphs:
+
+* in_degree
+* out_degree
+
 Examples
 ```ruby
-  wdigraph.get_edge(:D, :C).weight #=> 11
-  wdigraph.degree(:E) #=> 4
-  wdigraph.in_degree(:E) #=> 3
-  wdigraph.out_degree(:E) #=> 1
+  digraph.get_edge(:D, :C).weight #=> 11
+  digraph.degree(:E) #=> 4
+  digraph.in_degree(:E) #=> 3
+  digraph.out_degree(:E) #=> 1
 ```
 
 ## Searching
 
 Breadth First Search:
 ```ruby
-  BreadthFirstSearch.new(wdigraph).search(:A) #=> [:A, :C, :D, :G, :E, :F, :B]
+  BreadthFirstSearch.new(digraph).search(:A) #=> [:A, :C, :D, :G, :E, :F, :B]
 ```
 
 Depth First Search:
 ```ruby
-  DepthFirstSearch.new(wdigraph).search(:A) #=> [:A, :G, :B, :E, :D, :C, :F]
-`
+  DepthFirstSearch.new(digraph).search(:A) #=> [:A, :G, :B, :E, :D, :C, :F]
+```
+      
+You can also pass block to search methods:
+```ruby
+  DepthFirstSearch.new(digraph).search(:A) { |v| v.to_s.downcase }
+```
+
+If source vertex is not given, search method iterates over all vertexes in graph.
+
+## Topological Sort
+
+Topological Sort sorts vertexes in topological order (all edges in graph points in the same direction).
+Works only for digraphs without cycles (Directed Acyclic Graphs)
+
+```ruby
+  TopologicalSort.new(graph).sort #=> array of vertexes in topological order
+```
+
+## Connected Compontents
+
+ConnectedComponents finds all connected components in graph.
+
+```ruby
+  cc = ConnectedComponents.new(graph)
+  cc.count # => 1
+  cc.connected?(:a, :b) # => true
+```
+
+## Minimum Spanning Tree
+
+MinimumSpanningTree finds tree connecting all vertexes in graph with minimal weights.
+Implements Kruskal's algorithm.
+
+```ruby
+  tree = MinimumSpanningTree.new(graph).calculate #=> array of edges
+```
+
+
+## Shortest Paths
+
+Finds shortest paths from source to all vertexes in graph. Implements Dijkstra's algorithm and
+works only for digraphs with positive weights.
+
+Finding shortest paths in graph from vertex 0:
+```ruby
+  sp = ShortestPaths.new(digraph, 0)
+  sp.distance_to(7) #=>  returns shortest distance from vertex 0 to vertex 7
+  sp.has_path?(7) #=>  returns true if shortest path to 7 exists
+  sp.path_to(4) #=>  returns path from vertex 0 to vertex 4 (array of vertexes)
+```
+
 

data/lib/ogr.rb

@@ -9,8 +9,13 @@ require 'ogr/graphs/graph_as_tri_matrix'
 require 'ogr/graphs/edge_bag'
 require 'ogr/graphs/graph'
 require 'ogr/graphs/digraph'
-require 'ogr/graphs/breadth_first_search'
-require 'ogr/graphs/depth_first_search'
+require 'ogr/breadth_first_search'
+require 'ogr/depth_first_search'
+require 'ogr/topological_sort'
+require 'ogr/connected_components'
+require 'ogr/shortest_pahts'
+require 'ogr/minimum_spanning_tree'
+require 'ogr/union_find'
 
 # Main module namespace
 module Ogr

data/lib/ogr/{graphs/breadth_first_search.rb → breadth_first_search.rb}

@@ -1,27 +1,22 @@
 module Ogr
   # Class implements Breadth First Search in graphs
   class BreadthFirstSearch
-    attr_accessor :parents, :visited, :distance
-    private :parents=, :visited=, :distance=
+    attr_reader :parents, :visited, :distance
 
     def initialize(graph)
       @graph = graph
-      @colors = {}
+      @colors = Hash.new(:white)
       @parents = {}
       @visited = []
-      @distance = {}
+      @distance = Hash.new(Float::INFINITY)
       @to_visit = SimpleQueue.new
     end
 
-    def search(s)
-      # TODO: Check if source exists in graph
-      reset!
-      visit_source(s)
-      until to_visit.empty?
-        v = to_visit.dequeue
-        visit_neighbors(v)
-        colors[v] = :black
-        visited << (block_given? ? yield(v) : v)
+    def search(source = nil, &block)
+      if source
+        visit_source(source, &block)
+      else
+        graph.each_vertex { |v| visit_source(v, &block) unless visited?(v) }
       end
       visited
     end
@@ -30,20 +25,21 @@ module Ogr
 
     attr_accessor :graph, :to_visit, :colors
 
-    def reset!
-      self.visited = []
-      graph.each_vertex do |v|
-        colors[v] = :white
-        parents[v] = nil
-        distance[v] = Float::INFINITY
-      end
-    end
-
     def visit_source(s)
-      colors[s] = :white
-      parents[s] = nil
       distance[s] = 0
       to_visit.enqueue s
+      until to_visit.empty?
+        v = to_visit.dequeue
+        visit_neighbors(v)
+        colors[v] = :black
+        visited << (block_given? ? yield(v) : v)
+      end
+    end
+
+    def visit_neighbors(u)
+      graph.neighbors(u).each do |v|
+        visit_node(v, u) unless visited?(v)
+      end
     end
 
     def visit_node(v, from)
@@ -53,14 +49,8 @@ module Ogr
       to_visit.enqueue v
     end
 
-    def visit_neighbors(u)
-      graph.neighbors(u).each do |v|
-        visit_node(v, u) if not_visited?(v)
-      end
-    end
-
-    def not_visited?(v)
-      colors[v] == :white
+    def visited?(v)
+      colors[v] != :white
     end
   end
 end

data/lib/ogr/connected_components.rb

@@ -0,0 +1,58 @@
+module Ogr
+  # ConnectedComponents class finds graph components
+  class ConnectedComponents
+    attr_reader :graph, :visited, :counter, :stack
+    private :graph, :visited, :counter, :stack
+
+    def initialize(graph)
+      @graph = graph
+      @visited = {}
+      @counter = 0
+      find_components
+    end
+
+    def connected?(v, u)
+      visited[v] == visited[u]
+    end
+
+    def component(v)
+      visited[v]
+    end
+
+    def components
+      visited
+    end
+
+    def count
+      counter
+    end
+
+    private
+
+    def find_components
+      vertexes.each do |v|
+        unless visited[v]
+          dfs(v)
+          @counter += 1
+        end
+      end
+    end
+
+    def dfs(v)
+      @stack = [v]
+      while u = stack.pop
+        visit(u)
+      end
+    end
+
+    def visit(v)
+      return if visited[v]
+      visited[v] = counter
+      stack.concat(graph.neighbors(v))
+    end
+
+    def vertexes
+      @vertexes ||= graph.vertexes
+    end
+  end
+end

data/lib/ogr/depth_first_search.rb

@@ -0,0 +1,38 @@
+module Ogr
+  # Class implements Depth First Search in graphs
+  class DepthFirstSearch
+    attr_reader :graph, :stack, :marked, :visited
+    private :graph, :stack, :marked
+
+    def initialize(graph)
+      @graph = graph
+      @marked = {}
+      @visited = []
+    end
+
+    def search(source = nil, &block)
+      if source
+        dfs(source, &block)
+      else
+        graph.vertexes.each { |v| dfs(v, &block) unless marked[v] }
+      end
+      visited
+    end
+
+    private
+
+    def dfs(v, &block)
+      @stack = [v]
+      while u = stack.pop
+        visit(u, &block)
+      end
+    end
+
+    def visit(v)
+      return if marked[v]
+      visited << (block_given? ? yield(v) : v)
+      marked[v] = true
+      stack.concat(graph.neighbors(v))
+    end
+  end
+end

data/lib/ogr/graphs/digraph.rb

@@ -12,6 +12,7 @@ module Ogr
       add_edges(edges)
     end
 
+    # Creates new graph implemented as matrix.
     def self.new_dense(args)
       new(args, :matrix)
     end

data/lib/ogr/graphs/graph.rb

@@ -24,15 +24,16 @@ module Ogr
       new(edges, :tri_matrix)
     end
 
-    # Adds new edge to graph.
+    # Creates new edge in graph.
     def add(x, y, weight = 1)
+      weight ||= 1
       @g.add(push(x), push(y), weight)
     end
 
     # Adds new edges to graph.
     def add_edges(edges)
       if edges[0].is_a? Array
-        edges.each { |e| add(e[0], e[1]) }
+        edges.each { |e| add(e[0], e[1], e[2]) }
       else
         edges.each { |e| add(e.from, e.to, e.weight) }
       end
@@ -70,34 +71,45 @@ module Ogr
       Edge.new(x, y, w) if w
     end
 
-    def vc
-      (0...vertexes.size)
+    # Vertex iterator
+    def each_vertex
+      vc.each { |v| yield vertexes[v] }
     end
 
+    # Edge iterator
+    def each_edge(&block)
+      @g.each_edge(vertexes, &block)
+    end
+
+    # Returns array of all graph vertexes
     def vertexes
       @map.to_a
     end
 
+    # Vertex size
     def vertex_size
       vertexes.size
     end
 
-    # Vertex iterator
-    def each_vertex
-      vc.each { |v| yield vertexes[v] }
+    # Vertex numbers
+    def vc
+      (0...vertexes.size)
     end
 
-    # Edge iterator
-    def each_edge(&block)
-      @g.each_edge(vertexes, &block)
+    # Returns array of all graph edges
+    def edges
+      arr = []
+      each_edge { |e| arr << e }
+      arr
     end
 
-    private
-
+    # Internal numeric representation of vertex
     def index(x)
       @map.index(x)
     end
 
+    private
+
     def push(x)
       @map.push(x)
     end

data/lib/ogr/graphs/graph_as_list.rb

@@ -37,6 +37,7 @@ module Ogr
 
     # Returns all neighbors for given vertex.
     def neighbors(x)
+      return [] unless @store[x]
       @store[x].map { |edge| edge[:v] }
     end
 
@@ -44,8 +45,7 @@ module Ogr
     # edges, :out - outcoming edges, :all - incoming and outcoming edges.
     def degree(x, direction = :all)
       r = Hash.new(0)
-      vc = (0..@store.size)
-      vc.each do |i|
+      (0..@store.size).each do |i|
         r[:in] += 1 if  connected?(i, x)
         r[:out] += 1 if connected?(x, i)
       end

data/lib/ogr/minimum_spanning_tree.rb

@@ -0,0 +1,32 @@
+module Ogr
+  # Class implements Kruskal algorithm for finding Minimum Spanning Tree
+  class MinimumSpanningTree
+    attr_reader :graph, :uf
+    private :graph, :uf
+
+    def initialize(graph)
+      @graph = graph
+      @uf = UnionFind.new(@graph.vertexes.size)
+    end
+
+    def calculate
+      tree = []
+      while edge = edges.shift
+        from = graph.index(edge.from)
+        to = graph.index(edge.to)
+
+        unless uf.connected?(from, to)
+          uf.union(from, to)
+          tree << edge
+        end
+      end
+      tree
+    end
+
+    private
+
+    def edges
+      @edges ||= @graph.edges.sort_by(&:weight)
+    end
+  end
+end

data/lib/ogr/shortest_pahts.rb

@@ -0,0 +1,63 @@
+module Ogr
+  # Finds shortest paths in graph using Dijkstra algorithm
+  class ShortestPaths
+    attr_reader :parent, :distance, :graph, :queue
+    private :parent, :distance, :graph, :queue
+
+    def initialize(graph, source)
+      @graph = graph
+      @queue = IndexedPriorityQueue.min
+      @parent = {}
+      @distance = {}
+      @graph.vertexes.each { |v| @distance[v] = Float::INFINITY }
+
+      find_paths(source)
+    end
+
+    def distance_to(goal)
+      distance[goal]
+    end
+
+    def from(goal)
+      parent[goal]
+    end
+
+    def path?(goal)
+      distance[goal] < Float::INFINITY
+    end
+
+    def path_to(goal)
+      v = goal
+      path = [v]
+      path.push v while v = parent[v]
+      path.reverse
+    end
+
+    def find_paths(source)
+      distance[source] = 0
+      queue.push(source, 0)
+
+      while v = queue.shift
+        graph.neighbors(v).each do |u|
+          relax(graph.get_edge(v, u))
+        end
+      end
+    end
+
+    def relax(edge)
+      new_distance = distance[edge.from] + edge.weight
+      found_better(edge, new_distance) if new_distance < distance[edge.to]
+    end
+
+    def found_better(edge, new_distance)
+      v = edge.to
+      distance[v] = new_distance
+      parent[v] = edge.from
+      if queue.include?(v)
+        queue.update(v, new_distance)
+      else
+        queue.push(v, new_distance)
+      end
+    end
+  end
+end

data/lib/ogr/topological_sort.rb

@@ -0,0 +1,28 @@
+module Ogr
+  # Sorts graph vertexes in topological order
+  class TopologicalSort
+    attr_reader :graph, :sorted, :marked
+    private :graph, :sorted, :marked
+
+    def initialize(graph)
+      @graph = graph
+      @marked = {}
+      @sorted = []
+    end
+
+    def sort
+      graph.vertexes.each { |v| dfs(v) unless marked[v] }
+      sorted.reverse
+    end
+
+    private
+
+    def dfs(v)
+      marked[v] = true
+      graph.neighbors(v).reverse_each do |u|
+        dfs(u) unless marked[u]
+      end
+      sorted.push v
+    end
+  end
+end

data/lib/ogr/union_find.rb

@@ -0,0 +1,39 @@
+module Ogr
+  # Class implements Union Find algorithm
+  class UnionFind
+    attr_reader :store, :sizes
+    private :store, :sizes
+
+    def initialize(n)
+      @store = (0..n).to_a
+      @sizes = [1] * n
+    end
+
+    def connected?(x, y)
+      root(x) == root(y)
+    end
+
+    def union(x, y)
+      root_x = root(x)
+      root_y = root(y)
+      if sizes[root_y] > sizes[root_x]
+        update_sizes(root_x, root_y)
+      else
+        update_sizes(root_y, root_x)
+      end
+    end
+
+    private
+
+    def update_sizes(x, y)
+      store[x] = y
+      sizes[y] += sizes[x]
+    end
+
+    def root(x)
+      parent = store[x]
+      parent = store[parent] while parent != store[parent]
+      parent
+    end
+  end
+end

data/lib/ogr/version.rb

@@ -1,3 +1,3 @@
 module Ogr
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/ogr.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'ds', '~> 0.0'
+  spec.add_runtime_dependency 'ds', '>= 0.0.7'
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ogr
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - knife
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-02 00:00:00.000000000 Z
+date: 2016-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ds
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: 0.0.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.0'
+        version: 0.0.7
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -83,8 +83,9 @@ files:
 - bin/console
 - bin/setup
 - lib/ogr.rb
-- lib/ogr/graphs/breadth_first_search.rb
-- lib/ogr/graphs/depth_first_search.rb
+- lib/ogr/breadth_first_search.rb
+- lib/ogr/connected_components.rb
+- lib/ogr/depth_first_search.rb
 - lib/ogr/graphs/digraph.rb
 - lib/ogr/graphs/edge.rb
 - lib/ogr/graphs/edge_bag.rb
@@ -92,6 +93,10 @@ files:
 - lib/ogr/graphs/graph_as_list.rb
 - lib/ogr/graphs/graph_as_matrix.rb
 - lib/ogr/graphs/graph_as_tri_matrix.rb
+- lib/ogr/minimum_spanning_tree.rb
+- lib/ogr/shortest_pahts.rb
+- lib/ogr/topological_sort.rb
+- lib/ogr/union_find.rb
 - lib/ogr/version.rb
 - ogr.gemspec
 homepage: https://github.com/knife/ogr

data/lib/ogr/graphs/depth_first_search.rb

@@ -1,40 +0,0 @@
-module Ogr
-  # Class implements Breadth First Search in graphs
-  class DepthFirstSearch
-    attr_accessor :parents, :visited, :distance, :marked
-    private :parents=, :visited=, :distance=, :marked=
-
-    def initialize(graph)
-      @graph = graph
-      @parents = {}
-      @marked = {}
-      @visited = []
-      @distance = {}
-    end
-
-    def search(u, &block)
-      reset!
-      dfs(u, &block)
-      visited
-    end
-
-    def dfs(v, from = nil, &block)
-      marked[v] = true
-      visited << (block_given? ? yield(v) : v)
-      parents[v] = from
-      graph.neighbors(v).reverse_each do |u|
-        dfs(u, v, &block) unless marked[u]
-      end
-    end
-
-    private
-
-    attr_reader :graph
-
-    def reset!
-      self.visited = []
-      self.parents = {}
-      self.marked = {}
-    end
-  end
-end