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

Author: nantonel

.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

TODO.md

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

appveyor.yml

@@ -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/Project.toml

@@ -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,
 )

docs/make.jl

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

src/StructuredOptimization.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/calculus/precomposeNonlinear.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