Merge branch 'master' into min-travis-bump

Author: ChrisRackauckas

.travis.yml

@@ -4,7 +4,6 @@ os:
   - linux
   - osx
 julia:
-  - 1.1
   - 1.3
   - nightly
 matrix:

Project.toml

@@ -10,6 +10,7 @@ Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 DiffEqDiffTools = "01453d9d-ee7c-5054-8395-0335cb756afa"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
+InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"

src/coloring/acyclic_coloring.jl

@@ -41,14 +41,14 @@ function color_graph(g::LightGraphs.AbstractGraph, ::AcyclicColoring)
 
         color[v] = min_index(forbidden_colors, v)
 
-        #grow star for every edge connecting colored vertices v and w
+        # grow star for every edge connecting colored vertices v and w
         for w in outneighbors(g, v)
             if color[w] != 0
                 grow_star!(set, v, w, g, first_neighbor, color)
             end
         end
 
-        #merge the newly formed stars into existing trees if possible
+        # merge the newly formed stars into existing trees if possible
         for w in outneighbors(g, v)
             if color[w] != 0
                 for x in outneighbors(g, w)
@@ -66,14 +66,14 @@ function color_graph(g::LightGraphs.AbstractGraph, ::AcyclicColoring)
 end
 
 """
-        prevent_cycle(v::Integer,
-                    w::Integer,
-                    x::Integer,
-                    g::LightGraphs.AbstractGraph,
-                    color::AbstractVector{<:Integer},
-                    forbidden_colors::AbstractVector{<:Integer},
-                    first_visit_to_tree::Array{Tuple{Integer, Integer}, 1},
-                    set::DisjointSets{LightGraphs.Edge})
+    prevent_cycle(v::Integer,
+                w::Integer,
+                x::Integer,
+                g::LightGraphs.AbstractGraph,
+                color::AbstractVector{<:Integer},
+                forbidden_colors::AbstractVector{<:Integer},
+                first_visit_to_tree::Array{Tuple{Integer, Integer}, 1},
+                set::DisjointSets{LightGraphs.Edge})
 
 Subroutine to avoid generation of 2-colored cycle due to coloring of vertex v,
 which is adjacent to vertices w and x in graph g. Disjoint set is used to store
@@ -85,7 +85,7 @@ function prevent_cycle(v::Integer,
                         g::LightGraphs.AbstractGraph,
                         color::AbstractVector{<:Integer},
                         forbidden_colors::AbstractVector{<:Integer},
-                        first_visit_to_tree::AbstractVector{<: Tuple{Integer, Integer}},
+                        first_visit_to_tree::AbstractVector{<:Tuple{Integer, Integer}},
                         set::DisjointSets{LightGraphs.Edge})
 
     edge = find_edge(g, w, x)
@@ -108,13 +108,14 @@ function min_index(forbidden_colors::AbstractVector{<:Integer}, v::Integer)
 end
 
 """
-        grow_star!(set::DisjointSets{LightGraphs.Edge},
+    grow_star!(set::DisjointSets{LightGraphs.Edge},
                 v::Integer,
                 w::Integer,
-                g::LightGraphs.AbstractGraph
-                first_neighbor::Array{Tuple{Integer, Integer}, 1})
+                g::LightGraphs.AbstractGraph,
+                first_neighbor::AbstractVector{<:Tuple{Integer, Integer}},
+                color::AbstractVector{<: Integer})
 
-Subroutine to grow a 2-colored star after assigning a new color to the
+Grow a 2-colored star after assigning a new color to the
 previously uncolored vertex v, by comparing it with the adjacent vertex w.
 Disjoint set is used to store stars in sets, which are identified through key
 edges present in g.
@@ -123,7 +124,7 @@ function grow_star!(set::DisjointSets{LightGraphs.Edge},
                    v::Integer,
                    w::Integer,
                    g::LightGraphs.AbstractGraph,
-                   first_neighbor::AbstractArray{<: Tuple{Integer, Integer}, 1},
+                   first_neighbor::AbstractVector{<:Tuple{Integer, Integer}},
                    color::AbstractVector{<: Integer})
     edge = find_edge(g, v, w)
     push!(set, edge)

src/coloring/backtracking_coloring.jl

@@ -1,9 +1,9 @@
 """
-    color_graph(g::LightGraphs, ::BacktrackingColor)
+    color_graph(g::LightGraphs.AbstractGraph, ::BacktrackingColor)
 
-Returns a tight, distance-1 coloring of graph g
+Return a tight, distance-1 coloring of graph g
 using the minimum number of colors possible (i.e.
-the chromatic number of graph, χ(g))
+the chromatic number of graph, `χ(g)`)
 """
 function color_graph(g::LightGraphs.AbstractGraph, ::BacktrackingColor)
     v = nv(g)
@@ -181,9 +181,7 @@ function free_colors(x::Integer,
             push!(freecolors, c)
         end
     end
-
     return freecolors
-
 end
 
 """

src/coloring/contraction_coloring.jl

@@ -1,5 +1,5 @@
 """
-    ColorContraction
+    color_graph(G::VSafeGraph,::ContractionColor)
 
 Find a coloring of the graph g such that no two vertices connected
 by an edge have the same color.
@@ -37,7 +37,6 @@ function color_graph(G::VSafeGraph,::ContractionColor)
         V = nv(G)
     end
     return colors
-
 end
 
 
@@ -47,8 +46,7 @@ end
 Find the vertex in the group nn of vertices belonging to the
 graph G which has the highest degree.
 """
-function max_degree_vertex(G::VSafeGraph,nn::Array{Int,1})
-
+function max_degree_vertex(G::VSafeGraph, nn::Vector{Int})
     max_degree = -1
     max_degree_vertex = -1
     for v in nn
@@ -59,7 +57,6 @@ function max_degree_vertex(G::VSafeGraph,nn::Array{Int,1})
         end
     end
     return max_degree_vertex
-
 end
 
 
@@ -80,17 +77,16 @@ function max_degree_vertex(G::VSafeGraph)
         end
     end
     return max_degree_vertex
-
 end
 
 
 """
-    non_neighbors(G,x)
+    non_neighbors(G, x)
 
 Find the set of vertices belonging to the graph G which do
 not share an edge with the vertex x.
 """
-function non_neighbors(G::VSafeGraph, x::Int)
+function non_neighbors(G::VSafeGraph, x::Integer)
 
     nn = zeros(Int, 0)
     for v in vertices(G)
@@ -102,20 +98,18 @@ function non_neighbors(G::VSafeGraph, x::Int)
         end
     end
     return nn
-
 end
 
 
 """
-    length_common_neighbor(G,z,x)
+    length_common_neighbor(g, z, x)
 
 Find the number of vertices that share an edge with both the
-vertices z and x belonging to the graph G.
+vertices z and x belonging to the graph g.
 """
-function length_common_neighbor(G::VSafeGraph,z::Int, x::Int)
-
-    z_neighbors = inneighbors(G,z)
-    x_neighbors = inneighbors(G,x)
+function length_common_neighbor(g::VSafeGraph, z::Int, x::Int)
+    z_neighbors = inneighbors(g, z)
+    x_neighbors = inneighbors(g, x)
     common_vertices = indexin(z_neighbors, x_neighbors)
     num_common_vertices = 0
     for i in common_vertices
@@ -124,36 +118,28 @@ function length_common_neighbor(G::VSafeGraph,z::Int, x::Int)
         end
     end
     return num_common_vertices
-
 end
 
 
 """
-    vertex_degree(G,z)
+    vertex_degree(g, z)
 
-Find the degree of the vertex z which belongs to the graph G.
+Find the degree of the vertex z which belongs to the graph g.
 """
-function vertex_degree(G::VSafeGraph,z::Int)
-
-    return length(inneighbors(G,z))
-
-end
-
+vertex_degree(G::VSafeGraph,z::Int) = length(inneighbors(G,z))
 
 """
-    contract!(G,y,x)
+    contract!(g, y, x)
 
 Contract the vertex y to x, both of which belong to graph G, that is
 delete vertex y and join x with the neighbors of y if they are not
 already connected with an edge.
 """
-function contract!(G::VSafeGraph,y::Int, x::Int)
-
-    for v in inneighbors(G,y)
-        if has_edge(G,v,x) == false
-            add_edge!(G,v,x)
+function contract!(g::VSafeGraph, y::Int, x::Int)
+    for v in inneighbors(g, y)
+        if !has_edge(g, v, x)
+            add_edge!(g, v, x)
         end
     end
-    rem_vertex!(G,y)
-
+    rem_vertex!(g, y)
 end

src/coloring/greedy_d1_coloring.jl

@@ -1,25 +1,25 @@
 """
-        greedy_d1_coloring
+    color_graph(g::VSafeGraph, alg::GreedyD1Color)
 
 Find a coloring of a given input graph such that
 no two vertices connected by an edge have the same
 color using greedy approach. The number of colors
 used may be equal or greater than the chromatic
-number χ(G) of the graph.
+number `χ(G)` of the graph.
 """
 function color_graph(g::VSafeGraph, alg::GreedyD1Color)
     v = nv(g)
     result = zeros(Int, v)
     result[1] = 1
-    available = BitArray(undef, v)
+    available = BitVector(undef, v)
     for i = 2:v
         for j in inneighbors(g, i)
             if result[j] != 0
                 available[result[j]] = true
             end
         end
         for cr = 1:v
-            if available[cr] == false
+            if !available[cr]
                 result[i] = cr
                 break
             end

src/coloring/greedy_star1_coloring.jl

@@ -1,25 +1,25 @@
 """
         greedy_star1_coloring
 
-    Find a coloring of a given input graph such that
-    no two vertices connected by an edge have the same
-    color using greedy approach. The number of colors
-    used may be equal or greater than the chromatic
-    number `χ(G)` of the graph.
+Find a coloring of a given input graph such that
+no two vertices connected by an edge have the same
+color using greedy approach. The number of colors
+used may be equal or greater than the chromatic
+number `χ(G)` of the graph.
 
-    A star coloring is a special type of distance - 1  coloring,
-    For a coloring to be called a star coloring, it must satisfy
-    two conditions:
+A star coloring is a special type of distance - 1  coloring,
+For a coloring to be called a star coloring, it must satisfy
+two conditions:
 
-    1. every pair of adjacent vertices receives distinct  colors
-    (a distance-1 coloring)
+1. every pair of adjacent vertices receives distinct  colors
+(a distance-1 coloring)
 
-    2. For any vertex v, any color that leads to a two-colored path
-    involving v and three other vertices  is  impermissible  for  v.
-    In other words, every path on four vertices uses at least three
-    colors.
+2. For any vertex v, any color that leads to a two-colored path
+involving v and three other vertices  is  impermissible  for  v.
+In other words, every path on four vertices uses at least three
+colors.
 
-    Reference: Gebremedhin AH, Manne F, Pothen A. **What color is your Jacobian? Graph coloring for computing derivatives.** SIAM review. 2005;47(4):629-705.
+Reference: Gebremedhin AH, Manne F, Pothen A. **What color is your Jacobian? Graph coloring for computing derivatives.** SIAM review. 2005;47(4):629-705.
 """
 function color_graph(g::LightGraphs.AbstractGraph, ::GreedyStar1Color)
     v = nv(g)

src/coloring/greedy_star2_coloring.jl

@@ -1,37 +1,35 @@
 """
         greedy_star2_coloring
 
-    Find a coloring of a given input graph such that
-    no two vertices connected by an edge have the same
-    color using greedy approach. The number of colors
-    used may be equal or greater than the chromatic
-    number `χ(G)` of the graph.
+Find a coloring of a given input graph such that
+no two vertices connected by an edge have the same
+color using greedy approach. The number of colors
+used may be equal or greater than the chromatic
+number `χ(G)` of the graph.
 
-    A star coloring is a special type of distance - 1  coloring,
-    For a coloring to be called a star coloring, it must satisfy
-    two conditions:
+A star coloring is a special type of distance - 1  coloring,
+For a coloring to be called a star coloring, it must satisfy
+two conditions:
 
-    1. every pair of adjacent vertices receives distinct  colors
-    (a distance-1 coloring)
+1. every pair of adjacent vertices receives distinct  colors
+(a distance-1 coloring)
 
-    2. For any vertex v, any color that leads to a two-colored path
-    involving v and three other vertices  is  impermissible  for  v.
-    In other words, every path on four vertices uses at least three
-    colors.
+2. For any vertex v, any color that leads to a two-colored path
+involving v and three other vertices  is  impermissible  for  v.
+In other words, every path on four vertices uses at least three
+colors.
 
-    Reference: Gebremedhin AH, Manne F, Pothen A. **What color is your Jacobian? Graph coloring for computing derivatives.** SIAM review. 2005;47(4):629-705.
+Reference: Gebremedhin AH, Manne F, Pothen A. **What color is your Jacobian? Graph coloring for computing derivatives.** SIAM review. 2005;47(4):629-705.
 
-    TODO: add text explaining the difference between star1 and
-    star2
+TODO: add text explaining the difference between star1 and star2
 """
-function color_graph(g::LightGraphs.AbstractGraph, :: GreedyStar2Color)
+function color_graph(g::LightGraphs.AbstractGraph, ::GreedyStar2Color)
     v = nv(g)
     colorvec = zeros(Int, v)
 
     forbidden_colors = zeros(Int, v+1)
 
     for vertex_i = vertices(g)
-
         for w in inneighbors(g, vertex_i)
             if colorvec[w] != 0
                 forbidden_colors[colorvec[w]] = vertex_i
@@ -49,9 +47,7 @@ function color_graph(g::LightGraphs.AbstractGraph, :: GreedyStar2Color)
                 end
             end
         end
-
         colorvec[vertex_i] = find_min_color(forbidden_colors, vertex_i)
     end
-
-    colorvec
+    return colorvec
 end

src/coloring/high_level.jl

@@ -7,12 +7,11 @@ struct GreedyStar2Color <: SparseDiffToolsColoringAlgorithm end
 struct AcyclicColoring <: SparseDiffToolsColoringAlgorithm end
 
 """
-    matrix_colors(A,alg::ColoringAlgorithm = GreedyD1Color())
-
-    Returns the colorvec vector for the matrix A using the chosen coloring
-    algorithm. If a known analytical solution exists, that is used instead.
-    The coloring defaults to a greedy distance-1 coloring.
+    matrix_colors(A, alg::ColoringAlgorithm = GreedyD1Color())
 
+Return the colorvec vector for the matrix A using the chosen coloring
+algorithm. If a known analytical solution exists, that is used instead.
+The coloring defaults to a greedy distance-1 coloring.
 """
 function ArrayInterface.matrix_colors(A::AbstractMatrix, alg::SparseDiffToolsColoringAlgorithm = GreedyD1Color(); partition_by_rows::Bool = false)
     _A = A isa SparseMatrixCSC ? A : sparse(A) # Avoid the copy