Removing BlockArrays (#17)

* removed blockarrays

* dropped julia 0.7

* removed some weird comments

* no test in indaffine for 1.0

* fixing docs

* fix docs 2

.gitignore

@@ -8,7 +8,9 @@
 *.jpg
 *.wav
 *.tex
+*.DS_Store
 
 demos/.ipynb_checkpoints/
 docs/build/
 docs/site/
+docs/Manifest.toml

.travis.yml

@@ -4,8 +4,8 @@ os:
   - linux
   - osx
 julia:
-  - 0.7
   - 1.0
+  - 1.1
   - nightly
 matrix:
   allow_failures:
@@ -15,5 +15,14 @@ notifications:
 after_success:
   - julia -e 'using Pkg; cd(Pkg.dir("StructuredOptimization")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder())'
   - julia -e 'using Pkg; cd(Pkg.dir("StructuredOptimization")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
-  - julia -e 'using Pkg; ps=Pkg.PackageSpec(name="Documenter", version="0.19"); Pkg.add(ps); Pkg.pin(ps)'
-  - julia -e 'using Pkg; cd(Pkg.dir("StructuredOptimization")); include(joinpath("docs", "make.jl"))'
+
+jobs:
+  include:
+    - stage: "Documentation"
+      julia: 1.1
+      os: linux
+      script:
+        - julia --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd()));
+                                               Pkg.instantiate()'
+        - julia --project=docs/ docs/make.jl
+      after_success: skip

REQUIRE

@@ -1,6 +1,7 @@
-julia 0.7
+julia 1.0
 FFTW 0.2.4
 DSP 0.5.1
 AbstractOperators 0.1.0
 ProximalOperators 0.8.0
 ProximalAlgorithms 0.1.0
+RecursiveArrayTools 0.18.0

appveyor.yml

@@ -1,7 +1,7 @@
 environment:
   matrix:
-  - julia_version: 0.7
   - julia_version: 1
+  - julia_version: 1.1
   - julia_version: nightly
 
 platform:

docs/Project.toml

@@ -0,0 +1,5 @@
+[deps]
+AbstractOperators = "d9c5613a-d543-52d8-9afd-8f241a8c3f1c"
+DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"
+Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"

docs/make.jl

@@ -1,11 +1,11 @@
-using Documenter, StructuredOptimization, LinearAlgebra, DSP, AbstractFFTs, FFTW, AbstractOperators
+using Documenter, StructuredOptimization, LinearAlgebra, DSP, FFTW, AbstractOperators
 
 makedocs(
   modules = [StructuredOptimization],
-  format = :html,
+  format = Documenter.HTML(),
   sitename = "StructuredOptimization",
   authors = "Niccolò Antonello and Lorenzo Stella",
-  pages = Any[
+  pages = [
   "Home"                  => "index.md",
   "Quick Tutorial Guide"  => "tutorial.md",
   "Expressions"           => "expressions.md",
@@ -16,10 +16,6 @@ makedocs(
 )
 
 deploydocs(
-  repo   = "github.com/kul-forbes/StructuredOptimization.jl.git",
-  julia  = "1.0",
-  osname = "linux",
+  repo   = "github.com/kul-forbes/AbstractOperators.jl.git",
   target = "build",
-  deps = nothing,
-  make = nothing,
 )

src/StructuredOptimization.jl

@@ -3,8 +3,8 @@ __precompile__()
 module StructuredOptimization
 
 using LinearAlgebra
+using RecursiveArrayTools
 using AbstractOperators
-using AbstractOperators.BlockArrays
 using ProximalOperators
 using ProximalAlgorithms
 

src/calculus/precomposeNonlinear.jl

@@ -1,23 +1,26 @@
-import ProximalOperators: gradient! # this can be removed when moved to Prox
+import ProximalOperators: gradient!, gradient # this can be removed when moved to Prox
 
 export PrecomposeNonlinear
 
 struct PrecomposeNonlinear{P <: ProximableFunction, 
                            T <: AbstractOperator,
-                           D, C
+                           D <: AbstractArray, 
+                           C <: AbstractArray
                           } <: ProximableFunction
 	g::P
-    G::T
-    bufD::D
-    bufC::C
-    bufC2::C
+  G::T
+  bufD::D
+  bufC::C
+  bufC2::C
 end
 
 function PrecomposeNonlinear(g::P, G::T) where {P, T} 
-    bufD  = blockzeros(domainType(G),  size(G,2)) 
-    bufC  = blockzeros(codomainType(G),size(G,1)) 
-    bufC2 = blockzeros(codomainType(G),size(G,1)) 
-    PrecomposeNonlinear{P, T, typeof(bufD), typeof(bufC)}(g, G, bufD, bufC, bufC2)
+  t, s = domainType(G), size(G,2)
+  bufD = eltype(s) <: Int ? zeros(t,s) : ArrayPartition(zeros.(t,s))
+  t, s = codomainType(G), size(G,1)
+  bufC = eltype(s) <: Int ? zeros(t,s) : ArrayPartition(zeros.(t,s))
+  bufC2 = eltype(s) <: Int ? zeros(t,s) : ArrayPartition(zeros.(t,s))
+  PrecomposeNonlinear{P, T, typeof(bufD), typeof(bufC)}(g, G, bufD, bufC, bufC2)
 end
 
 is_smooth(f::PrecomposeNonlinear) = is_smooth(f.g)
@@ -26,7 +29,22 @@ function (f::PrecomposeNonlinear)(x)
     return f.g(f.G*x)
 end
 
-function gradient!(y::D, f::PrecomposeNonlinear{P,T,D,C}, x::D) where {P,T,D,C}
+function gradient(f::PrecomposeNonlinear, x::ArrayPartition)
+  y = zero(x)
+  fy = gradient!(y,f,x)
+  return y, fy
+end
+
+#TODO simplify this
+function gradient!(y::D, f::PrecomposeNonlinear{P,T,D,C}, x::D) where {P,T,D <: ArrayPartition,C}
+    mul!(f.bufC, f.G, x)
+    v = gradient!(f.bufC2, f.g, f.bufC)
+    J = Jacobian(f.G, x)
+    y = mul!(y, J', f.bufC2)
+    return v
+end
+
+function gradient!(y::D, f::PrecomposeNonlinear{P,T,D,C}, x::D) where {P,T,D <: AbstractArray,C}
     mul!(f.bufC, f.G, x)
     v = gradient!(f.bufC2, f.g, f.bufC)
     J = Jacobian(f.G, x)

src/solvers/build_solve.jl

@@ -85,7 +85,7 @@ julia> solve!(x_solver);
 function solve!(x_and_iter::Tuple{Tuple{Vararg{Variable}}, ProximalAlgorithms.ProximalAlgorithm})
     x, iterator = x_and_iter
     it, x_star = ProximalAlgorithms.run!(iterator)
-    blockset!(~x, x_star)
+    ~x .= x_star
     return it, iterator 
 end
 

src/syntax/expressions/addition.jl

@@ -48,35 +48,31 @@ function (+)(a::AbstractExpression, b::AbstractExpression)
 	A = convert(Expression,a)
 	B = convert(Expression,b)
 	if variables(A) == variables(B)
-		return Expression{length(A.x)}(A.x,affine(A)+affine(B))
+    return Expression{length(A.x)}(A.x,affine(A)+affine(B))
 	else
-		opA = affine(A)
-		xA = variables(A)
-		opB = affine(B)
-		xB = variables(B)
-
-		xNew, opNew = Usum_op(xA,xB,opA,opB,true)
-		return Expression{length(xNew)}(xNew,opNew)
+    opA = affine(A)
+    xA = variables(A)
+    opB = affine(B)
+    xB = variables(B)
+    xNew, opNew = Usum_op(xA,xB,opA,opB,true)
+    return Expression{length(xNew)}(xNew,opNew)
 	end
-
 end
 # sum expressions
 
 function (-)(a::AbstractExpression, b::AbstractExpression)
 	A = convert(Expression,a)
 	B = convert(Expression,b)
 	if variables(A) == variables(B)
-		return Expression{length(A.x)}(A.x,affine(A)-affine(B))
+    return Expression{length(A.x)}(A.x,affine(A)-affine(B))
 	else
-		opA = affine(A)
-		xA = variables(A)
-		opB = affine(B)
-		xB = variables(B)
-
-		xNew, opNew = Usum_op(xA,xB,opA,opB,false)
-		return Expression{length(xNew)}(xNew,opNew)
+    opA = affine(A)
+    xA = variables(A)
+    opB = affine(B)
+    xB = variables(B)
+    xNew, opNew = Usum_op(xA,xB,opA,opB,false)
+    return Expression{length(xNew)}(xNew,opNew)
 	end
-
 end
 
 #unsigned sum affines with single variables
@@ -93,33 +89,32 @@ end
 function Usum_op(xA::NTuple{N,Variable},
 		 xB::Tuple{Variable},
 		 A::L1,
-		 B::AbstractOperator,sign::Bool) where {N, M, L1<:HCAT{M,N}}
+		 B::AbstractOperator,sign::Bool) where {N, M, L1<:HCAT{N}}
 	if xB[1] in xA
-        idx = findfirst(xA.==Ref(xB[1]))
-		S = sign ? A[idx]+B : A[idx]-B
-		xNew = xA
-		opNew = hcat(A[1:idx-1],S,A[idx+1:N]  )
+    idx = findfirst(xA.==Ref(xB[1]))
+    S = sign ? A[idx]+B : A[idx]-B
+    xNew = xA
+    opNew = hcat(A[1:idx-1],S,A[idx+1:N]  )
 	else
-		xNew  = (xA...,xB...)
-		opNew = sign ? hcat(A,B) : hcat(A,-B)
+    xNew  = (xA...,xB...)
+    opNew = sign ? hcat(A,B) : hcat(A,-B)
 	end
-
 	return xNew, opNew
 end
 
 #unsigned sum: AbstractOperator+HCAT
 function Usum_op(xA::Tuple{Variable},
 		 xB::NTuple{N,Variable},
 		 A::AbstractOperator,
-		 B::L2,sign::Bool) where {N, M, L2<:HCAT{M,N}}
-	if xA[1] in xB
-        idx = findfirst(xA.==Ref(xB[1]))
-		S = sign ? A+B[idx] : B[idx]-A
-		xNew = xB
-		opNew = sign ? hcat(B[1:idx-1],S,B[idx+1:N]  ) : -hcat(B[1:idx-1],S,B[idx+1:N]  )
+		 B::L2,sign::Bool) where {N, M, L2<:HCAT{N}}
+  if xA[1] in xB
+    idx = findfirst(xA.==Ref(xB[1]))
+    S = sign ? A+B[idx] : B[idx]-A
+    xNew = xB
+    opNew = sign ? hcat(B[1:idx-1],S,B[idx+1:N]  ) : -hcat(B[1:idx-1],S,B[idx+1:N]  )
 	else
-		xNew  = (xA...,xB...)
-		opNew = sign ? hcat(A,B) : hcat(A,-B)
+    xNew  = (xA...,xB...)
+    opNew = sign ? hcat(A,B) : hcat(A,-B)
 	end
 
 	return xNew, opNew
@@ -130,12 +125,12 @@ function Usum_op(xA::NTuple{NA,Variable},
 		 xB::NTuple{NB,Variable},
 		 A::L1,
 		 B::L2,sign::Bool) where {NA,NB,M,
-					  L1<:HCAT{M,NB},
-					  L2<:HCAT{M,NB}     }
+					  L1<:HCAT{NB},
+					  L2<:HCAT{NB}     }
 	xNew = xA
 	opNew = A
 	for i in eachindex(xB)
-		xNew, opNew = Usum_op(xNew, (xB[i],), opNew, B[i], sign)
+    xNew, opNew = Usum_op(xNew, (xB[i],), opNew, B[i], sign)
 	end
 return xNew,opNew
 end
@@ -146,12 +141,12 @@ function Usum_op(xA::NTuple{N,Variable},
 		 A::AbstractOperator,
 		 B::AbstractOperator,sign::Bool) where {N}
 	if xB[1] in xA
-		Z = Zeros(A)       #this will be an HCAT
-		xNew, opNew = Usum_op(xA,xB,Z,B,sign)
-		opNew += A
+    Z = Zeros(A)       #this will be an HCAT
+    xNew, opNew = Usum_op(xA,xB,Z,B,sign)
+    opNew += A
 	else
-		xNew  = (xA...,xB...)
-		opNew = sign ? hcat(A,B) : hcat(A,-B)
+    xNew  = (xA...,xB...)
+    opNew = sign ? hcat(A,B) : hcat(A,-B)
 	end
 	return xNew, opNew
 end
@@ -190,19 +185,19 @@ julia> ex + b
 """
 function (+)(a::AbstractExpression, b::Union{AbstractArray,Number}) 
 	A = convert(Expression,a)
-    return Expression{length(A.x)}(A.x,AffineAdd(affine(A),b))
+  return Expression{length(A.x)}(A.x,AffineAdd(affine(A),b))
 end
 
 (+)(a::Union{AbstractArray,Number}, b::AbstractExpression) = b+a
 
 function (-)(a::AbstractExpression, b::Union{AbstractArray,Number})
 	A = convert(Expression,a)
-    return Expression{length(A.x)}(A.x,AffineAdd(affine(A),b,false))
+  return Expression{length(A.x)}(A.x,AffineAdd(affine(A),b,false))
 end
 
 function (-)(a::Union{AbstractArray,Number}, b::AbstractExpression)
 	B = convert(Expression,b)
-    return Expression{length(B.x)}(B.x,-AffineAdd(affine(B),a))
+  return Expression{length(B.x)}(B.x,-AffineAdd(affine(B),a))
 end
 # sum with array/scalar
 
@@ -212,14 +207,14 @@ function Broadcast.broadcasted(::typeof(+),a::AbstractExpression, b::AbstractExp
 	A = convert(Expression,a)
 	B = convert(Expression,b)
 	if size(affine(A),1) != size(affine(B),1)
-		if prod(size(affine(A),1)) > prod(size(affine(B),1))
-			B = Expression{length(B.x)}(variables(B),
-						    BroadCast(affine(B),size(affine(A),1)))
-		elseif prod(size(affine(B),1)) > prod(size(affine(A),1))
-			A = Expression{length(A.x)}(variables(A),
-						    BroadCast(affine(A),size(affine(B),1)))
-		end
-		return A+B
+    if prod(size(affine(A),1)) > prod(size(affine(B),1))
+      B = Expression{length(B.x)}(variables(B),
+                                  BroadCast(affine(B),size(affine(A),1)))
+    elseif prod(size(affine(B),1)) > prod(size(affine(A),1))
+      A = Expression{length(A.x)}(variables(A),
+                                  BroadCast(affine(A),size(affine(B),1)))
+    end
+    return A+B
 	end
 	return A+B
 end
@@ -228,14 +223,14 @@ function Broadcast.broadcasted(::typeof(-),a::AbstractExpression, b::AbstractExp
 	A = convert(Expression,a)
 	B = convert(Expression,b)
 	if size(affine(A),1) != size(affine(B),1)
-		if prod(size(affine(A),1)) > prod(size(affine(B),1))
-			B = Expression{length(B.x)}(variables(B),
-						    BroadCast(affine(B),size(affine(A),1)))
-		elseif prod(size(affine(B),1)) > prod(size(affine(A),1))
-			A = Expression{length(A.x)}(variables(A),
-						    BroadCast(affine(A),size(affine(B),1)))
-		end
-		return A-B
+    if prod(size(affine(A),1)) > prod(size(affine(B),1))
+      B = Expression{length(B.x)}(variables(B),
+                                  BroadCast(affine(B),size(affine(A),1)))
+    elseif prod(size(affine(B),1)) > prod(size(affine(A),1))
+      A = Expression{length(A.x)}(variables(A),
+                                  BroadCast(affine(A),size(affine(B),1)))
+    end
+    return A-B
 	end
 	return A-B
 end