added remove_displacement

Author: nantonel

src/calculus/AffineAdd.jl

@@ -94,3 +94,5 @@ end
 
 displacement(A::AffineAdd{L,D,true})  where {L,D} =  A.d+displacement(A.A)
 displacement(A::AffineAdd{L,D,false}) where {L,D} = -A.d+displacement(A.A)
+
+remove_displacement(A::AffineAdd) = remove_displacement(A.A)

src/calculus/BroadCast.jl

@@ -116,3 +116,4 @@ is_linear(      R::BroadCast) = is_linear(R.A)
 is_null(        R::BroadCast) = is_null(R.A)
 
 fun_name(R::BroadCast) = "."fun_name(R.A)
+remove_displacement(B::BroadCast) = BroadCast(remove_displacement(B.A), B.dim_out, B.bufC, B.bufD)

src/calculus/Compose.jl

@@ -121,3 +121,5 @@ function permute(C::Compose, p::AbstractVector{Int})
 	Compose(AA,C.buf)
 
 end
+
+remove_displacement(C::Compose) = Compose(remove_displacement.(C.A),C.buf)

src/calculus/DCAT.jl

@@ -210,6 +210,8 @@ function permute(H::DCAT{N,L,P1,P2}, p::AbstractVector{Int}) where {N,L,P1,P2}
 	DCAT(H.A,new_part,H.idxC)
 end
 
+remove_displacement(D::DCAT) = DCAT(remove_displacement.(D.A), D.idxD, D.idxC)
+
 # special cases
 # Eye constructor
 Eye(x::A) where {N, A <: NTuple{N,AbstractArray}} = DCAT(Eye.(x)...)

src/calculus/HCAT.jl

@@ -320,3 +320,5 @@ function permute(H::HCAT{M,N,L,P,C}, p::AbstractVector{Int}) where {M,N,L,P,C}
 
 	HCAT{M,N,L,P,C}(H.A,new_part,H.buf)
 end
+
+remove_displacement(H::HCAT{M}) where {M} = HCAT(remove_displacement.(H.A), H.idxs, H.buf, M)

src/calculus/Hadamard.jl

@@ -30,22 +30,22 @@ true
 
 struct Hadamard{M, C, V <: VCAT{M}} <: NonLinearOperator
 	A::V
-	mid::C
-	mid2::C
-	function Hadamard(A::V, mid::C, mid2::C) where {M, C, V <: VCAT{M}}
+	buf::C
+	buf2::C
+	function Hadamard(A::V, buf::C, buf2::C) where {M, C, V <: VCAT{M}}
 		any([ai != size(A,1)[1] for ai in size(A,1)]) &&
 		throw(DimensionMismatch("cannot compose operators"))
 
-		new{M, C, V}(A,mid,mid2)
+		new{M, C, V}(A,buf,buf2)
 	end
 end
 
 struct HadamardJacobian{M, C, V <: VCAT{M}} <: LinearOperator
 	A::V
-	mid::C
-	mid2::C
-	function HadamardJacobian(A::V,mid::C,mid2::C) where {M, C, V <: VCAT{M}}
-		new{M, C, V}(A,mid,mid2)
+	buf::C
+	buf2::C
+	function HadamardJacobian(A::V,buf::C,buf2::C) where {M, C, V <: VCAT{M}}
+		new{M, C, V}(A,buf,buf2)
 	end
 end
 
@@ -57,32 +57,32 @@ function Hadamard(L1::AbstractOperator,L2::AbstractOperator)
 
     V = VCAT(A,B)
 
-	mid  = zeros.(codomainType(V), size(V,1))
-	mid2 = zeros.(codomainType(V), size(V,1))
+	buf  = zeros.(codomainType(V), size(V,1))
+	buf2 = zeros.(codomainType(V), size(V,1))
 
-	Hadamard(V,mid,mid2)
+	Hadamard(V,buf,buf2)
 end
 
 # Mappings
 function A_mul_B!(y, H::Hadamard{M,C,V}, b) where {M,C,V}
-	A_mul_B!(H.mid,H.A,b)
+	A_mul_B!(H.buf,H.A,b)
 
-	y .= H.mid[1]
-    for i = 2:length(H.mid)
-		y .*= H.mid[i]
+	y .= H.buf[1]
+    for i = 2:length(H.buf)
+		y .*= H.buf[i]
 	end
 end
 
 # Jacobian
 Jacobian(A::H, x::D) where {M, D<:Tuple, C, V, H <: Hadamard{M,C,V}} =
-HadamardJacobian(Jacobian(A.A,x),A.mid,A.mid2)
+HadamardJacobian(Jacobian(A.A,x),A.buf,A.buf2)
 
 function Ac_mul_B!(y, J::HadamardJacobian{M,C,V}, b) where {M,C,V}
-    for i = 1:length(J.mid)
-		c = (J.mid[1:i-1]...,J.mid[i+1:end]...,b)
-		J.mid2[i] .= (.*)(c...)
+    for i = 1:length(J.buf)
+		c = (J.buf[1:i-1]...,J.buf[i+1:end]...,b)
+		J.buf2[i] .= (.*)(c...)
 	end
-	Ac_mul_B!(y, J.A, J.mid2)
+	Ac_mul_B!(y, J.A, J.buf2)
 
 end
 
@@ -104,5 +104,7 @@ import Base: permute
 
 function permute(H::Hadamard, p::AbstractVector{Int})
     A = VCAT([permute(a,p) for a in H.A.A]...)
-    Hadamard(A,H.mid,H.mid2)
+    Hadamard(A,H.buf,H.buf2)
 end
+
+remove_displacement(N::Hadamard) = Hadamard(remove_displacement(N.A), N.buf, N.buf2)

src/calculus/NonLinearCompose.jl

@@ -143,5 +143,4 @@ function permute(P::NonLinearCompose{N,L,C,D}, p::AbstractVector{Int}) where {N,
 	NonLinearCompose(permute(P.A,p),permute(P.B,p),P.buf,P.bufx)
 end
 
-
-
+remove_displacement(N::NonLinearCompose) = NonLinearCompose(remove_displacement(N.A), remove_displacement(N.B), N.buf, N.bufx)

src/calculus/Reshape.jl

@@ -68,3 +68,4 @@ is_full_row_rank(  R::Reshape)    = is_full_row_rank(     R.A)
 is_full_column_rank(  R::Reshape) = is_full_column_rank(  R.A)
 
 fun_name(R::Reshape) = "¶"*fun_name(R.A)
+remove_displacement(R::Reshape) = Reshape(remove_displacement(R.A), R.dim_out)

src/calculus/Scale.jl

@@ -100,3 +100,4 @@ fun_type(L::Scale) = fun_type(L.A)
 diag(L::Scale) = L.coeff*diag(L.A)
 diag_AcA(L::Scale) = (L.coeff)^2*diag_AcA(L.A)
 diag_AAc(L::Scale) = (L.coeff)^2*diag_AAc(L.A)
+remove_displacement(S::Scale) = Scale(S.coeff, S.coeff_conj, remove_displacement(S.A) )

src/calculus/Sum.jl

@@ -117,3 +117,4 @@ function permute(S::Sum{M,N}, p::AbstractVector{Int}) where {M,N}
     return Sum(AA,S.bufC,S.bufD[p],M,N)
 end
 
+remove_displacement(S::Sum{M,N}) where {M,N} = Sum(remove_displacement.(S.A), S.bufC, S.bufD, M, N)