Merge branch 'master' into boostgeneral

src/Blocks/Blocks.jl

@@ -37,7 +37,7 @@ include("MatrixBlock.jl")
 # others
 include("Measure.jl")
 include("Sequential.jl")
-include("Functor.jl")
+include("Function.jl")
 include("IOSyntax.jl")
 include("blockoperations.jl")
 

src/Blocks/Function.jl

@@ -0,0 +1,17 @@
+export FunctionBlock
+
+"""
+    FunctionBlock <: AbstractBlock
+
+This block contains a general function that perform an in-place operation over a register
+"""
+struct FunctionBlock{FT} <: AbstractBlock
+    apply!
+    function FunctionBlock{FT}(f) where FT
+        !isempty(methods(f)) || throw(ArgumentError("Input is not callable!"))
+        new{FT}(f)
+    end
+end
+
+FunctionBlock(f) = FunctionBlock{typeof(f)}(f)
+apply!(reg::AbstractRegister, f::FunctionBlock) = f.apply!(reg)

src/Interfaces/Composite.jl

@@ -101,10 +101,6 @@ function control(controls, target)
     total->ControlBlock{total}(decode_sign(controls...)..., target.second, target.first)
 end
 
-function control(total::Int, controls)
-    x::Pair->ControlBlock{total}(decode_sign(controls...)..., x.second, x.first)
-end
-
 function control(controls)
     function _control(x::Pair)
         total->ControlBlock{total}(decode_sign(controls...)..., x.second, x.first)

src/Interfaces/Function.jl

@@ -0,0 +1,37 @@
+export @fn, InvOrder, addbit, Reset
+
+macro fn(f)
+    :(FunctionBlock($(esc(f))))
+end
+
+macro fn(name::Symbol, f)
+    FT = FunctionBlock{name}
+    :($FT($(esc(f))))
+end
+
+"""
+    macro fn([name,] f)
+
+Define a in-place function on a register inside circuits.
+"""
+:(@fn)
+
+"""
+    InvOrder
+
+Return a [`FunctionBlock`](@ref) of inversing the order.
+"""
+const InvOrder = @fn InvOrder invorder!
+
+"""
+    Reset
+"""
+const Reset = @fn Reset reset!
+
+
+"""
+    addbit(n::Int) -> FunctionBlock{:AddBit}
+
+Return a [`FunctionBlock`](@ref) of adding n bits.
+"""
+addbit(n::Int) = FunctionBlock{Tuple{:AddBit, n}}(reg->addbit!(reg, n))

src/Interfaces/Interfaces.jl

@@ -22,7 +22,7 @@ include("Signal.jl")
 include("Primitive.jl")
 include("Composite.jl")
 include("Measure.jl")
-include("Functor.jl")
+include("Function.jl")
 include("Sequential.jl")
 include("Cache.jl")
 

src/Registers/Default.jl

@@ -160,7 +160,6 @@ function addbit!(reg::DefaultRegister{B, T}, n::Int) where {B, T}
 end
 
 function reset!(reg::DefaultRegister)
-    println(reg)
     reg.state .= 0
     reg.state[1,:] .= 1
     reg

test/Blocks/Blocks.jl

@@ -29,8 +29,8 @@ end
 include("Measure.jl")
 end
 
-@testset "functor" begin
-include("Functor.jl")
+@testset "function" begin
+include("Function.jl")
 end
 
 @testset "sequential" begin

test/Blocks/Daggered.jl

@@ -33,7 +33,6 @@ end
     @test GP isa Daggered
     @test mat(GP) == mat(ConstG)'
     @test adjoint(adjoint(ConstG)) === ConstG
-    println(chain(GP, GP))
 end
 
 @testset "copy dispatch" begin

test/Blocks/Function.jl

@@ -0,0 +1,11 @@
+using Compat
+using Compat.Test
+
+using Yao
+using Yao.Blocks
+
+@testset "functor" begin
+    Test_InvOrder = FunctionBlock(invorder!)
+    reg = rand_state(4)
+    @test copy(reg) |> invorder! == apply!(copy(reg), Test_InvOrder)
+end

test/Boost/applys.jl

@@ -6,12 +6,6 @@ using Yao.Blocks
 using Yao.Intrinsics
 using Yao.LuxurySparse
 
-# import Yao: xapply!, yapply!, zapply!, cxapply!, cyapply!, czapply!
-
-# struct Register{N, T<:Complex}
-#     state::Vector{T}
-# end
-
 @testset "xyz" begin
     @test linop2dense(s->xapply!(s, [1]), 1) == mat(X)
     @test linop2dense(s->yapply!(s, [1]), 1) == mat(Y)

test/Interfaces/Interfaces.jl

@@ -53,9 +53,6 @@ end
     @test control(3, [1, 2], 3=>X) isa ControlBlock
     @test control(5, 1:2, 3=>X) isa ControlBlock
 
-    @test (1=>X) |> control(8, i for i in [2, 3, 6, 7]) isa ControlBlock
-    @test ((1=>X) |> control(i for i in [2, 3, 6, 7]))(8) isa ControlBlock
-
     @test ((1=>X) |> C(2, 3))(4) isa ControlBlock
 end
 
@@ -100,17 +97,16 @@ end
     @test Rz(1) isa RotationGate
 end
 
-@testset "functors" begin
+@testset "functions" begin
     reg = rand_state(3, 2)
-    println(typeof(InvOrder))
-    @test InvOrder isa Functor{:InvOrder}
+    @test InvOrder isa FunctionBlock{:InvOrder}
     @test apply!(copy(reg), InvOrder) == copy(reg) |> invorder!
 
-    @test addbit(3) isa Functor{:AddBit}
+    @test addbit(3) isa FunctionBlock{Tuple{:AddBit, 3}}
     @test apply!(copy(reg), addbit(2)) |> state == kron(zero_state(2) |> state, reg |> state)
 
-    Probs = @functor probs
-    @test Probs isa Functor{:Default}
+    Probs = @fn probs
+    @test Probs isa FunctionBlock{typeof(probs)}
     @test apply!(copy(reg), Probs) == reg |> probs
 end
 
@@ -122,7 +118,6 @@ end
     @test sqs == sequence(kron(5, 3=>X), addbit(3), MEASURE) == sequence((kron(5, 3=>X), addbit(3), MEASURE))
     insert!(sqs, 3, kron(8, 8=>X))
     push!(sqs, Reset)
-    println(sqs)
     reg = register(bit"11111") |> sqs
     @test MEASURE.result[] == 155
     @test reg == zero_state(8)

test/Registers/Registers.jl

@@ -8,3 +8,7 @@ using Compat.SparseArrays
     include("Default.jl")
     include("Focus.jl")
 end
+
+@testset "reorder" begin
+include("reorder.jl")
+end

test/Registers/reorder.jl

@@ -19,7 +19,6 @@ using Yao.Intrinsics
 
 
     v1, v2, v3 = randn(2), randn(2), randn(2)
-    using Compat.Test
     @test repeat(register(v1 ⊗ v2 ⊗ v3), 2) |> invorder! ≈ repeat(register(v3 ⊗ v2 ⊗ v1), 2)
 
 end

test/Zoo/Differential.jl

@@ -6,7 +6,6 @@ using Compat.Test
 
 @testset "rotter, collect_rotblocks, num_gradient, opgrad" begin
     c = diff_circuit(4, 3, [1=>3, 2=>4, 2=>3, 4=>1])
-    println(c)
     rots = collect_rotblocks(c)
     @test length(rots) == nparameters(c) == 40
 

test/Zoo/QFT.jl

@@ -15,7 +15,6 @@ end
     @test Matrix(mat(chain(3, QFT(3) |> adjoint, QFT(3)))) ≈ eye(1<<3)
 
     # test ifft
-    println(ifftblock)
     reg1 = copy(reg) |>ifftblock
 
     # permute lines (Manually)

test/runtests.jl

@@ -30,7 +30,7 @@ end
    include("Interfaces/Interfaces.jl")
 end
 
-@testset "gallery" begin
+@testset "zoo" begin
    include("Zoo/Zoo.jl")
 end