Name changes

src/SimpleGraphs.jl

@@ -56,6 +56,6 @@ include("embedding/embedding.jl")
 
 include("hyper/SimpleHypergraphs.jl")
 
-include("abbreviations.jl")
+# include("abbreviations.jl")
 
 end # module SimpleGraphs

src/abbreviations.jl

@@ -1,13 +1,9 @@
-const UG = SimpleGraph
-const DG = SimpleDigraph
-# const HG = SimpleHypergraph
-export UG, DG
+
 
 
 # These names will not be necessary in versions 0.8.1 and on
 
-const UndirectedGraph = SimpleGraph
-const DirectedGraph = SimpleDigraph
+const DirectedGraph = DirectedGraph
 const HyperGraph = HyperGraph
 
-export UndirectedGraph, DirectedGraph, HyperGraph
+export DirectedGraph, HyperGraph

src/bisect.jl

@@ -21,7 +21,7 @@ This can be invoked as follows:
 A plain call to `bisect(G)` is equivalent to `bisect(G,"zero")` (which
 is the same as `bisect(G,"user", 0.0)`).
 """
-function bisect(G::SimpleGraph, where::AbstractString = "zero", pivot::Real = 0.0)
+function bisect(G::UndirectedGraph, where::AbstractString = "zero", pivot::Real = 0.0)
 
     verbose = false
 
@@ -100,7 +100,7 @@ end
 one end in `A` and one end in `B`. Here `A` and `B` are collections
 of vertices of `G`.
 """
-function cross_edges(G::SimpleGraph, A, B)
+function cross_edges(G::UndirectedGraph, A, B)
 
     AB = Base.Iterators.product(A, B)
 

src/cache.jl

@@ -13,35 +13,35 @@ export cache_clear, cache_on, cache_off, cache_recall, cache_check, cache_save
 
 `cache_clear(G,item)` clears just that item.
 """
-function cache_clear(G::SimpleGraph)
+function cache_clear(G::UndirectedGraph)
     if length(G.cache) > 0
         G.cache = Dict{Symbol,Any}()
     end
     nothing
 end
 
-cache_clear(G::SimpleGraph, item::Symbol) = delete!(G.cache, item)
+cache_clear(G::UndirectedGraph, item::Symbol) = delete!(G.cache, item)
 
 """
 `cache_check(G,item)` checks if the symbol `item` is a valid key.
 """
-cache_check(G::SimpleGraph, item::Symbol)::Bool = G.cache_flag && haskey(G.cache, item)
+cache_check(G::UndirectedGraph, item::Symbol)::Bool = G.cache_flag && haskey(G.cache, item)
 
 """
 `cache_recall(G,item)` retreives the value associated with `item`.
 
 **WARNING**: No check is done to see if this value is defined. Be
 sure to use `cache_check` first!
 """
-cache_recall(G::SimpleGraph, item::Symbol) = G.cache[item]
+cache_recall(G::UndirectedGraph, item::Symbol) = G.cache[item]
 
 
 
 """
 `cache_save(G,item,value)` saves `value` associated with
 the symbol (key) `item` in the cache for this graph.
 """
-function cache_save(G::SimpleGraph, item::Symbol, value)
+function cache_save(G::UndirectedGraph, item::Symbol, value)
     if G.cache_flag
         G.cache[item] = value
     end
@@ -51,14 +51,14 @@ end
 """
 `cache_on(G)` activates results caching for this graph. See also: `cache_off`.
 """
-cache_on(G::SimpleGraph) = G.cache_flag = true
+cache_on(G::UndirectedGraph) = G.cache_flag = true
 
 """
 `cache_off(G)` deactivates cache checking. You may also wish to call
 `cache_clear` to recover storage.
 
 See also: `cache_on`.
 """
-function cache_off(G::SimpleGraph)
+function cache_off(G::UndirectedGraph)
     G.cache_flag = false
 end

src/d_dist.jl

@@ -1,5 +1,5 @@
 
-function dist_matrix(G::SimpleDigraph)
+function dist_matrix(G::DirectedGraph)
     VV = vlist(G)
     n = length(VV)
     A = zeros(Int, n, n)
@@ -12,7 +12,7 @@ function dist_matrix(G::SimpleDigraph)
     return A
 end
 
-function diam(G::SimpleDigraph)
+function diam(G::DirectedGraph)
     A = dist_matrix(G)
     if minimum(A) < 0
         return -1

src/d_euler.jl

@@ -1,6 +1,6 @@
 export euler, is_cut_edge
 
-function euler(G::SimpleDigraph{T}, u::T, v::T) where {T}
+function euler(G::DirectedGraph{T}, u::T, v::T) where {T}
     notrail = T[]
     #check in_degrees and out_degrees of start and end vertex first
     if u == v
@@ -25,12 +25,12 @@ function euler(G::SimpleDigraph{T}, u::T, v::T) where {T}
     return euler_work!(GG, u)
 end
 
-euler(G::SimpleDigraph, u) = euler(G, u, u)
-euler(G::SimpleDigraph) = euler(G, first(G.V))
+euler(G::DirectedGraph, u) = euler(G, u, u)
+euler(G::DirectedGraph) = euler(G, first(G.V))
 
 
 # determine if an edge in a directed graph is a cut edge
-function is_cut_edge(G::SimpleDigraph{T}, u::T, v::T) where {T}
+function is_cut_edge(G::DirectedGraph{T}, u::T, v::T) where {T}
     if !has(G, u, v)
         error("No such edge in this graph")
     end
@@ -48,7 +48,7 @@ end
 
 # helper function to determine if there is euler path
 # function euler_work!(G::SimpleDigraph{T}, u::T) where {T}
-function euler_work!(G::SimpleDigraph{T}, u::T) where {T}
+function euler_work!(G::DirectedGraph{T}, u::T) where {T}
     trail = T[]
     while true
         Nu = out_neighbors(G, u)

src/d_ham.jl

@@ -1,7 +1,7 @@
 export hamiltonian_cycle
 
 #check if it is safe to add vertex v to the path
-function isSafe(v::T, G::SimpleDigraph{T}, path::Deque{T}) where {T}
+function isSafe(v::T, G::DirectedGraph{T}, path::Deque{T}) where {T}
     prev = last(path)
 
     #check if the added vertex is an out_neighbor of the previous vertex
@@ -21,7 +21,7 @@ function isSafe(v::T, G::SimpleDigraph{T}, path::Deque{T}) where {T}
     return true
 end
 
-function hamCycle(G::SimpleDigraph{T}, path::Deque{T}) where {T}
+function hamCycle(G::DirectedGraph{T}, path::Deque{T}) where {T}
     #if all vertices are included in the cycle
     if length(path) == NV(G)
         #check if last vertex is connected to first vertex in path
@@ -49,7 +49,7 @@ function hamCycle(G::SimpleDigraph{T}, path::Deque{T}) where {T}
 end
 
 #check if a directed graph contains a hamiltonian cycle
-function directed_ham_cycle(G::SimpleDigraph{T}) where {T}
+function directed_ham_cycle(G::DirectedGraph{T}) where {T}
     result = Deque{T}()
     vlist = collect(G.V)
 
@@ -72,6 +72,6 @@ function directed_ham_cycle(G::SimpleDigraph{T}) where {T}
 end
 
 #export the result as an array
-function hamiltonian_cycle(G::SimpleDigraph{T}) where {T}
+function hamiltonian_cycle(G::DirectedGraph{T}) where {T}
     return collect(directed_ham_cycle(G))
 end

src/d_simple_constructors.jl

@@ -118,7 +118,7 @@ function ShiftDigraph(alphabet = [0, 1], n::Int = 3)
     vertex_iter = all_tuples(alphabet, n)
     vlist = collect(vertex_iter)
     T = typeof(vlist[1])
-    G = SimpleDigraph{T}()
+    G = DirectedGraph{T}()
     for v in vlist
         add!(G, v)
     end
@@ -143,7 +143,7 @@ function for creating a Torus Graph
 function TorusDigraph(n::Int = 4, m::Int = 3)
 
     T = Tuple{Int,Int}
-    G = SimpleDigraph{T}()
+    G = DirectedGraph{T}()
 
     #create vertices
     vlist = Tuple{Int,Int}[]