Some fixes

Author: YingboMa

src/bipartite_graph.jl

@@ -66,13 +66,13 @@ badjlist = [[1,2,5,6],[3,4,6]]
 bg = BipartiteGraph(7, fadjlist, badjlist)
 ```
 """
-mutable struct BipartiteGraph{I<:Integer,F<:Vector{Vector{I}},B<:Union{Vector{Vector{I}},Nothing},M} <: LightGraphs.AbstractGraph{I}
+mutable struct BipartiteGraph{I<:Integer,F<:Vector{Vector{I}},B<:Union{Vector{Vector{I}},I},M} <: LightGraphs.AbstractGraph{I}
     ne::Int
     fadjlist::F # `fadjlist[src] => dsts`
-    badjlist::B # `badjlist[dst] => srcs`
+    badjlist::B # `badjlist[dst] => srcs` or `ndsts`
     metadata::M
 end
-BipartiteGraph(ne::Integer, fadj::AbstractVector, badj::Union{AbstractVector}=nothing) = BipartiteGraph(ne, fadj, badj, nothing)
+BipartiteGraph(ne::Integer, fadj::AbstractVector, badj::Union{AbstractVector}=maximum(maximum, fadj); metadata=nothing) = BipartiteGraph(ne, fadj, badj, metadata)
 
 """
 ```julia
@@ -84,9 +84,7 @@ Test whether two [`BipartiteGraph`](@ref)s are equal.
 function Base.isequal(bg1::BipartiteGraph{T}, bg2::BipartiteGraph{T}) where {T<:Integer}
     iseq = (bg1.ne == bg2.ne)
     iseq &= (bg1.fadjlist == bg2.fadjlist)
-    if bg1.badjlist !== nothing && bg2.badjlist !== nothing
-        iseq &= (bg1.badjlist == bg2.badjlist)
-    end
+    iseq &= (bg1.badjlist == bg2.badjlist)
     iseq
 end
 
@@ -97,14 +95,18 @@ Build an empty `BipartiteGraph` with `nsrcs` sources and `ndsts` destinations.
 """
 function BipartiteGraph(nsrcs::T, ndsts::T, backedge::Val{B}=Val(true); metadata=nothing) where {T,B}
     fadjlist = map(_->T[], 1:nsrcs)
-    badjlist = B ? map(_->T[], 1:ndsts) : nothing
+    badjlist = B ? map(_->T[], 1:ndsts) : ndsts
     BipartiteGraph(0, fadjlist, badjlist, metadata)
 end
 
 Base.eltype(::Type{<:BipartiteGraph{I}}) where I = I
 function Base.empty!(g::BipartiteGraph)
     foreach(empty!, g.fadjlist)
-    g.badjlist === nothing || foreach(empty!, g.badjlist)
+    if g.badjlist isa AbstractVector
+        foreach(empty!, g.badjlist)
+    else
+        g.badjlist = 0
+    end
     g.ne = 0
     if g.metadata !== nothing
         foreach(empty!, g.metadata)
@@ -121,12 +123,12 @@ end
 LightGraphs.is_directed(::Type{<:BipartiteGraph}) = false
 LightGraphs.vertices(g::BipartiteGraph) = (𝑠vertices(g), 𝑑vertices(g))
 𝑠vertices(g::BipartiteGraph) = axes(g.fadjlist, 1)
-𝑑vertices(g::BipartiteGraph) = g.badjlist === nothing ? throw_no_back_edges() : axes(g.badjlist, 1)
+𝑑vertices(g::BipartiteGraph) = g.badjlist isa AbstractVector ? axes(g.badjlist, 1) : Base.OneTo(g.badjlist)
 has_𝑠vertex(g::BipartiteGraph, v::Integer) = v in 𝑠vertices(g)
 has_𝑑vertex(g::BipartiteGraph, v::Integer) = v in 𝑑vertices(g)
 𝑠neighbors(g::BipartiteGraph, i::Integer, with_metadata::Val{M}=Val(false)) where M = M ? zip(g.fadjlist[i], g.metadata[i]) : g.fadjlist[i]
 function 𝑑neighbors(g::BipartiteGraph, j::Integer, with_metadata::Val{M}=Val(false)) where M
-    g.badjlist === nothing && throw_no_back_edges()
+    g.badjlist isa AbstractVector || throw_no_back_edges()
     M ? zip(g.badjlist[j], (g.metadata[i][j] for i in g.badjlist[j])) : g.badjlist[j]
 end
 LightGraphs.ne(g::BipartiteGraph) = g.ne
@@ -152,7 +154,6 @@ const NO_METADATA = NoMetadata()
 LightGraphs.add_edge!(g::BipartiteGraph, i::Integer, j::Integer, md=NO_METADATA) = add_edge!(g, BipartiteEdge(i, j), md)
 function LightGraphs.add_edge!(g::BipartiteGraph, edge::BipartiteEdge, md=NO_METADATA)
     @unpack fadjlist, badjlist = g
-    verts = vertices(g)
     s, d = src(edge), dst(edge)
     (has_𝑠vertex(g, s) && has_𝑑vertex(g, d)) || error("edge ($edge) out of range.")
     @inbounds list = fadjlist[s]
@@ -164,7 +165,7 @@ function LightGraphs.add_edge!(g::BipartiteGraph, edge::BipartiteEdge, md=NO_MET
     end
 
     g.ne += 1
-    if badjlist !== nothing
+    if badjlist isa AbstractVector
         @inbounds list = badjlist[d]
         index = searchsortedfirst(list, s)
         insert!(list, index, s)
@@ -173,8 +174,12 @@ function LightGraphs.add_edge!(g::BipartiteGraph, edge::BipartiteEdge, md=NO_MET
 end
 
 function LightGraphs.add_vertex!(g::BipartiteGraph{T}, type::VertType) where T
-    if type === DST && g.badjlist !== nothing
-        push!(g.badjlist, T[])
+    if type === DST
+        if g.badjlist isa AbstractVector
+            push!(g.badjlist, T[])
+        else
+            g.badjlist += 1
+        end
     elseif type === SRC
         push!(g.fadjlist, T[])
     else

src/systems/systemstructure.jl

@@ -50,8 +50,8 @@ Base.@kwdef struct SystemStructure
     inv_varassoc::Vector{Int}
     varmask::BitVector # `true` if the variable has the highest order derivative
     algeqs::BitVector
-    graph::BipartiteGraph{Int,Vector{Vector{Int}},Nothing,Nothing}
-    solvable_graph::BipartiteGraph{Int,Vector{Vector{Int}},Nothing,Nothing}
+    graph::BipartiteGraph{Int,Vector{Vector{Int}},Int,Nothing}
+    solvable_graph::BipartiteGraph{Int,Vector{Vector{Int}},Int,Nothing}
     assign::Vector{Int}
     inv_assign::Vector{Int}
     scc::Vector{Vector{Int}}

test/reduction.jl

@@ -120,9 +120,9 @@ test_equal.(equations(reduced_system), reduced_eqs)
 
 observed_eqs = [
                 s ~ lorenz2.y
+                a ~ lorenz2.y - lorenz1.x
                 lorenz1.F ~ -((lorenz2.z) - (lorenz2.x) - (lorenz2.y))
                 lorenz2.F ~ -((lorenz1.z) - (lorenz1.x) - (lorenz1.y))
-                a ~ s - (lorenz1.x)
                 lorenz2.u ~ lorenz1.F
                 lorenz1.u ~ lorenz2.F
                ]

test/structural_transformation/tearing.jl

@@ -145,7 +145,7 @@ eqs = [
 daesys = ODESystem(eqs, t)
 newdaesys = tearing(daesys)
 @test equations(newdaesys) == [D(x) ~ z; 0 ~ x + sin(z) - p*t]
-@test isequal(states(newdaesys), [x, z])
+@test isequal(states(newdaesys), [z, x])
 prob = ODAEProblem(newdaesys, [x=>1.0], (0, 1.0), [p=>0.2])
 du = [0.0]; u = [1.0]; pr = 0.2; tt = 0.1
 @test (@ballocated $(prob.f)($du, $u, $pr, $tt)) == 0

test/structural_transformation/utils.jl

@@ -20,20 +20,16 @@ sys = initialize_system_structure(pendulum)
 StructuralTransformations.find_solvables!(sys)
 sss = structure(sys)
 @unpack graph, solvable_graph, fullvars, varassoc = sss
-@test isequal(fullvars, [x, y, w, z, D(x), D(y), D(w), D(z), T])
-@test graph.fadjlist == sort.([[5, 3], [6, 4], [7, 1, 9], [8, 2, 9], [2, 1]])
-@test graph.badjlist == sort.([[3, 5], [4, 5], [1], [2], [1], [2], [3], [4], [3, 4]])
+@test isequal(fullvars, [w, D(x), x, z, D(y), y, T, D(w), D(z)])
+@test graph.fadjlist == sort.([[1, 2], [4, 5], [3, 7, 8], [6, 7, 9], [3, 6]])
+@test graph.badjlist == 9 == length(fullvars)
 @test ne(graph) == nnz(incidence_matrix(graph)) == 12
 @test nv(solvable_graph) == nv(solvable_graph) == 9 + 5
-@test varassoc == [5, 6, 7, 8, 0, 0, 0, 0, 0]
+@test varassoc == [8, 0, 2, 9, 0, 5, 0, 0, 0]
 
 se = collect(StructuralTransformations.𝑠edges(graph))
 @test se == mapreduce(vcat, enumerate(graph.fadjlist)) do (s, d)
     StructuralTransformations.BipartiteEdge.(s, d)
 end
-de = collect(StructuralTransformations.𝑑edges(graph))
-@test de == mapreduce(vcat, enumerate(graph.badjlist)) do (d, s)
-    StructuralTransformations.BipartiteEdge.(s, d)
-end
-ae = collect(StructuralTransformations.edges(graph))
-@test ae == vcat(se, de)
+@test_throws ArgumentError collect(StructuralTransformations.𝑑edges(graph))
+@test_throws ArgumentError collect(StructuralTransformations.edges(graph))