Add adapters.jl code

Author: Jack Dunham

src/ITensorNetworksNext.jl

@@ -6,5 +6,6 @@ include("tensornetwork.jl")
 include("contract_network.jl")
 include("abstract_problem.jl")
 include("iterators.jl")
+include("adapters.jl")
 
 end

src/adapters.jl

@@ -0,0 +1,45 @@
+"""
+  struct IncrementOnly{S<:AbstractNetworkIterator} <: AbstractNetworkIterator
+
+Iterator wrapper whos `compute!` function simply returns itself, doing nothing in the 
+process. This allows one to manually call a custom `compute!` or insert their own code it in
+the loop body in place of `compute!`.
+"""
+struct IncrementOnly{S <: AbstractNetworkIterator} <: AbstractNetworkIterator
+    parent::S
+end
+
+islaststep(adapter::IncrementOnly) = islaststep(adapter.parent)
+increment!(adapter::IncrementOnly) = increment!(adapter.parent)
+compute!(adapter::IncrementOnly) = adapter
+
+IncrementOnly(adapter::IncrementOnly) = adapter
+
+"""
+  struct EachRegion{SweepIterator} <: AbstractNetworkIterator
+
+Adapter that flattens each region iterator in the parent sweep iterator into a single
+iterator.
+"""
+struct EachRegion{SI <: SweepIterator} <: AbstractNetworkIterator
+    parent::SI
+end
+
+# In keeping with Julia convention.
+eachregion(iter::SweepIterator) = EachRegion(iter)
+
+# Essential definitions
+function islaststep(adapter::EachRegion)
+    region_iter = region_iterator(adapter.parent)
+    return islaststep(adapter.parent) && islaststep(region_iter)
+end
+function increment!(adapter::EachRegion)
+    region_iter = region_iterator(adapter.parent)
+    islaststep(region_iter) ? increment!(adapter.parent) : increment!(region_iter)
+    return adapter
+end
+function compute!(adapter::EachRegion)
+    region_iter = region_iterator(adapter.parent)
+    compute!(region_iter)
+    return adapter
+end

test/test_iterators.jl

@@ -1,6 +1,6 @@
 using Test: @test, @testset, @test_throws
 import ITensorNetworksNext as ITensorNetworks
-using .ITensorNetworks: RegionIterator, SweepIterator, compute!, increment!, islaststep, state
+using .ITensorNetworks: RegionIterator, SweepIterator, IncrementOnly, compute!, increment!, islaststep, state, eachregion
 
 module TestIteratorUtils
 
@@ -157,5 +157,65 @@ end
             @test SA_c == [1, 4, 9, 16, 25]
 
         end
+
+        @testset "IncrementOnly" begin
+            TI = TestIteratorUtils.TestIterator(1, 5, [])
+            NI = IncrementOnly(TI)
+
+            NI_c = []
+
+            for _ in IncrementOnly(TI)
+                push!(NI_c, state(TI))
+            end
+
+            @test length(NI_c) == 5
+            @test isempty(TI.output)
+        end
+
+        @testset "EachRegion" begin
+            prob = TestIteratorUtils.TestProblem([])
+            prob_region = TestIteratorUtils.TestProblem([])
+
+            SI = SweepIterator(prob, 5)
+            SI_region = SweepIterator(prob_region, 5)
+
+            callback = []
+            callback_region = []
+
+            let i = 1
+                for _ in SI
+                    push!(callback, i)
+                    i += 1
+                end
+            end
+
+            @test length(callback) == 5
+
+            let i = 1
+                for _ in eachregion(SI_region)
+                    push!(callback_region, i)
+                    i += 1
+                end
+            end
+
+            @test length(callback_region) == 10
+
+            @test prob.data == prob_region.data
+
+            @test prob.data[1:2:end] == fill(1, 5)
+            @test prob.data[2:2:end] == fill(2, 5)
+
+
+            let i = 1, prob = TestIteratorUtils.TestProblem([])
+                SI = SweepIterator(prob, 1)
+                cb = []
+                for _ in eachregion(SI)
+                    push!(cb, i)
+                    i += 1
+                end
+                @test length(cb) == 2
+            end
+
+        end
     end
 end