Julia 1.0 update (#13)

* starting 1.0 update

* test passing

* fixing travis and appveyor

* cleaned precomposeNonlinear mul! calls

* updated installation in docs

* fix to docs

Author: nantonel

.travis.yml

@@ -4,15 +4,16 @@ os:
   - linux
   - osx
 julia:
-  - 0.6
+  - 0.7
+  - 1.0
   - nightly
 matrix:
   allow_failures:
   - julia: nightly
 notifications:
   email: false
 after_success:
-  - julia -e 'cd(Pkg.dir("StructuredOptimization")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder())'
-  - julia -e 'cd(Pkg.dir("StructuredOptimization")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
-  - julia -e 'Pkg.add("Documenter")'
-  - julia -e 'cd(Pkg.dir("StructuredOptimization")); include(joinpath("docs", "make.jl"))'
+  - 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; Pkg.add("Documenter")'
+  - julia -e 'using Pkg; cd(Pkg.dir("StructuredOptimization")); include(joinpath("docs", "make.jl"))'

README.md

@@ -26,8 +26,11 @@ It supports complex variables as well.
 
 ## Installation
 
-From the Julia command line hit `Pkg.clone("https://github.com/kul-forbes/StructuredOptimization.jl.git")`.
-Once the package is installed you can update it along with the others issuing `Pkg.update()` in the command line.
+To install the package, hit `]` from the Julia command line to enter the package manager, then
+
+```julia
+pkg> add https://github.com/kul-forbes/StructuredOptimization.jl
+```
 
 ## Usage
 

REQUIRE

@@ -1,4 +1,6 @@
-julia 0.6
-AbstractOperators 0.0.5
-ProximalOperators 0.6.0
-ProximalAlgorithms 0.0.3
+julia 0.7
+FFTW 0.2.4
+DSP 0.5.1
+AbstractOperators 0.1.0
+ProximalOperators 0.8.0
+ProximalAlgorithms 0.1.0

appveyor.yml

@@ -1,7 +1,16 @@
 environment:
   matrix:
-    - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
-#    - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
+  - julia_version: 0.7
+  - julia_version: 1
+  - julia_version: nightly
+
+platform:
+#  - x86 # 32-bit
+  - x64 # 64-bit
+
+matrix:
+  allow_failures:
+  - julia_version: nightly
 
 branches:
   only:
@@ -15,19 +24,18 @@ notifications:
     on_build_status_changed: false
 
 install:
-  - ps: "[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12"
-# Download most recent Julia Windows binary
-  - ps: (new-object net.webclient).DownloadFile(
-        $env:JULIA_URL,
-        "C:\projects\julia-binary.exe")
-# Run installer silently, output to C:\projects\julia
-  - C:\projects\julia-binary.exe /S /D=C:\projects\julia
+  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
 
 build_script:
-# Need to convert from shallow to complete for Pkg.clone to work
-  - IF EXIST .git\shallow (git fetch --unshallow)
-  - C:\projects\julia\bin\julia -e "versioninfo();
-      Pkg.clone(pwd(), \"StructuredOptimization\"); Pkg.build(\"StructuredOptimization\")"
+  - echo "%JL_BUILD_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
 
 test_script:
-  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"StructuredOptimization\")"
+  - echo "%JL_TEST_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
+
+# # Uncomment to support code coverage upload. Should only be enabled for packages
+# # which would have coverage gaps without running on Windows
+# on_success:
+#   - echo "%JL_CODECOV_SCRIPT%"
+#   - C:\julia\bin\julia -e "%JL_CODECOV_SCRIPT%"

docs/make.jl

@@ -1,4 +1,4 @@
-using Documenter, StructuredOptimization
+using Documenter, StructuredOptimization, LinearAlgebra, DSP, AbstractFFTs, FFTW, AbstractOperators
 
 makedocs(
   modules = [StructuredOptimization],
@@ -17,7 +17,7 @@ makedocs(
 
 deploydocs(
   repo   = "github.com/kul-forbes/StructuredOptimization.jl.git",
-  julia  = "0.6",
+  julia  = "1.0",
   osname = "linux",
   target = "build",
   deps = nothing,

docs/src/index.md

@@ -18,9 +18,11 @@ StructuredOptimization.jl can handle large-scale convex and nonconvex problems w
 
 ## Installation
 
-From the Julia command line hit `Pkg.clone("https://github.com/kul-forbes/StructuredOptimization.jl.git")`.
-Once the package is installed you can update it along with the others issuing
-`Pkg.update()` in the command line.
+To install the package, hit `]` from the Julia command line to enter the package manager, then
+
+```julia
+pkg> add https://github.com/kul-forbes/StructuredOptimization.jl
+```
 
 ## Citing
 

src/StructuredOptimization.jl

@@ -2,6 +2,7 @@ __precompile__()
 
 module StructuredOptimization
 
+using LinearAlgebra
 using AbstractOperators
 using AbstractOperators.BlockArrays
 using ProximalOperators

src/calculus/precomposeNonlinear.jl

@@ -27,9 +27,9 @@ function (f::PrecomposeNonlinear)(x)
 end
 
 function gradient!(y::D, f::PrecomposeNonlinear{P,T,D,C}, x::D) where {P,T,D,C}
-    A_mul_B!(f.bufC, f.G, x)
+    mul!(f.bufC, f.G, x)
     v = gradient!(f.bufC2, f.g, f.bufC)
     J = Jacobian(f.G, x)
-    y = Ac_mul_B!(y, J, f.bufC2)
+    y = mul!(y, J', f.bufC2)
     return v
 end

src/solvers/solvers_options.jl

@@ -22,7 +22,7 @@ Creates an object `PG` containing the options of the Proximal Gradient solvers:
 
 """
 struct PG <: ForwardBackwardSolver
-    kwargs::Array
+    kwargs::Iterators.Pairs
     function PG(; kwargs...)
         new(kwargs)
     end
@@ -61,7 +61,7 @@ Creates an object `ZeroFPR` containing the options of the ZeroFPR solver:
 
 """
 struct ZeroFPR <: ForwardBackwardSolver
-    kwargs::Array
+    kwargs::Iterators.Pairs
     function ZeroFPR(; kwargs...)
         new(kwargs)
     end
@@ -90,7 +90,7 @@ Creates an object `PANOC` containing the options of the PANOC solver:
 
 """
 struct PANOC <: ForwardBackwardSolver
-    kwargs::Array
+    kwargs::Iterators.Pairs
     function PANOC(; kwargs...)
         new(kwargs)
     end

src/solvers/terms_extract.jl

@@ -1,7 +1,7 @@
 # returns all variables of a cost function, in terms of appearance
 extract_variables(t::Term) = variables(t) 
 
-function extract_variables{N}(t::NTuple{N,Term})
+function extract_variables(t::NTuple{N,Term}) where {N}
 	x = variables.(t)
 	xAll = x[1]
 	for i = 2:length(x)
@@ -21,15 +21,15 @@ function extract_functions(t::Term)
 	#TODO change this
 	return f
 end
-extract_functions{N}(t::NTuple{N,Term}) = SeparableSum(extract_functions.(t))
+extract_functions(t::NTuple{N,Term}) where {N} = SeparableSum(extract_functions.(t))
 extract_functions(t::Tuple{Term}) = extract_functions(t[1])
 
 # extract functions from terms without displacement
 function extract_functions_nodisp(t::Term)
 	f = t.lambda == 1. ? t.f : Postcompose(t.f, t.lambda)
 	return f
 end
-extract_functions_nodisp{N}(t::NTuple{N,Term}) = SeparableSum(extract_functions_nodisp.(t))
+extract_functions_nodisp(t::NTuple{N,Term}) where {N} = SeparableSum(extract_functions_nodisp.(t))
 extract_functions_nodisp(t::Tuple{Term}) = extract_functions_nodisp(t[1])
 
 # extract operators from terms
@@ -39,10 +39,10 @@ extract_functions_nodisp(t::Tuple{Term}) = extract_functions_nodisp(t[1])
 #single term, single variable
 extract_operators(xAll::Tuple{Variable}, t::Term)  = operator(t)
 
-extract_operators{N}(xAll::NTuple{N,Variable}, t::Term) = extract_operators(xAll, (t,))
+extract_operators(xAll::NTuple{N,Variable}, t::Term) where {N} = extract_operators(xAll, (t,))
 
 #multiple terms, multiple variables
-function extract_operators{N,M}(xAll::NTuple{N,Variable}, t::NTuple{M,Term})
+function extract_operators(xAll::NTuple{N,Variable}, t::NTuple{M,Term}) where {N,M}
 	ops = ()
 	for ti in t
 		tex = expand(xAll,ti)
@@ -53,7 +53,7 @@ end
 
 sort_and_extract_operators(xAll::Tuple{Variable}, t::Term) = operator(t)
 
-function sort_and_extract_operators{N}(xAll::NTuple{N,Variable}, t::Term)
+function sort_and_extract_operators(xAll::NTuple{N,Variable}, t::Term) where {N}
 	p = zeros(Int,N)
 	xL = variables(t)
 	for i in eachindex(xAll)
@@ -69,10 +69,10 @@ end
 #single term, single variable
 extract_affines(xAll::Tuple{Variable}, t::Term)  = affine(t)
 
-extract_affines{N}(xAll::NTuple{N,Variable}, t::Term) = extract_affines(xAll, (t,))
+extract_affines(xAll::NTuple{N,Variable}, t::Term) where {N} = extract_affines(xAll, (t,))
 
 #multiple terms, multiple variables
-function extract_affines{N,M}(xAll::NTuple{N,Variable}, t::NTuple{M,Term})
+function extract_affines(xAll::NTuple{N,Variable}, t::NTuple{M,Term}) where {N,M}
 	ops = ()
 	for ti in t
 		tex = expand(xAll,ti)
@@ -83,7 +83,7 @@ end
 
 sort_and_extract_affines(xAll::Tuple{Variable}, t::Term) = affine(t)
 
-function sort_and_extract_affines{N}(xAll::NTuple{N,Variable}, t::Term)
+function sort_and_extract_affines(xAll::NTuple{N,Variable}, t::Term) where {N}
 	p = zeros(Int,N)
 	xL = variables(t)
 	for i in eachindex(xAll)
@@ -93,7 +93,7 @@ function sort_and_extract_affines{N}(xAll::NTuple{N,Variable}, t::Term)
 end
 
 # expand term domain dimensions
-function expand{N,T1,T2,T3}(xAll::NTuple{N,Variable}, t::Term{T1,T2,T3})
+function expand(xAll::NTuple{N,Variable}, t::Term{T1,T2,T3}) where {N,T1,T2,T3}
 	xt   = variables(t)
 	C    = codomainType(operator(t))
 	size_out = size(operator(t),1)
@@ -165,4 +165,3 @@ end
 
 extract_proximable(xAll::Variable, t::Term) =  extract_merge_functions(t)
 extract_proximable(xAll::NTuple{N,Variable}, t::Term) where {N} = extract_proximable(xAll,(t,))
-

src/solvers/terms_splitting.jl

@@ -4,15 +4,15 @@
 #
 # Splits cost function into `SmoothFunction` and `NonSmoothFunction` terms.
 # """
-# split_smooth(cf::Vararg{Term}) = cf[find(is_smooth(cf))],cf[find((!).(is_smooth(cf)))]
+# split_smooth(cf::Vararg{Term}) = cf[findall(is_smooth(cf))],cf[findall((!).(is_smooth(cf)))]
 # split_smooth{N}(cf::NTuple{N,Term}) = split_smooth(cf...)
 #
 # """
 # `split_AAc_diagonal(cf::Vararg{Term}) -> (proximable, non_proximable)`
 #
 # Splits cost function into terms with L'*L diagonal operator.
 # """
-# split_AAc_diagonal(cf::Vararg{Term}) = cf[find(is_AAc_diagonal(cf))],cf[find((!).(is_AAc_diagonal(cf)))]
+# split_AAc_diagonal(cf::Vararg{Term}) = cf[findall(is_AAc_diagonal(cf))],cf[findall((!).(is_AAc_diagonal(cf)))]
 # split_AAc_diagonal{N}(cf::NTuple{N,Term}) = split_AAc_diagonal(cf...)
 #
 # #""" TODO
@@ -22,10 +22,10 @@
 # #"""
 
 split_smooth(terms::Tuple) =
-    terms[find(is_smooth.(terms))], terms[find((!).(is_smooth.(terms)))]
+    terms[findall(is_smooth.(terms))], terms[findall((!).(is_smooth.(terms)))]
 
 split_quadratic(terms::Tuple) =
-    terms[find(is_quadratic.(terms))], terms[find((!).(is_quadratic.(terms)))]
+    terms[findall(is_quadratic.(terms))], terms[findall((!).(is_quadratic.(terms)))]
 
 split_AAc_diagonal(terms::Tuple) =
-    terms[find(is_AAc_diagonal.(terms))], terms[find((!).(is_AAc_diagonal.(terms)))]
+    terms[findall(is_AAc_diagonal.(terms))], terms[findall((!).(is_AAc_diagonal.(terms)))]

src/syntax/expressions/abstractOperator_bind.jl

@@ -24,24 +24,32 @@ function reshape(a::AbstractExpression, dims...)
 end
 #Reshape
 
-imported = [:getindex :GetIndex;
-            :fft      :DFT;
+imported = [
+            :getindex :GetIndex;
+            :exp      :Exp;
+            :cos      :Cos;
+            :sin      :Sin;
+            :atan     :Atan;
+            :tanh     :Tanh;
+           ]
+
+importedFFTW = [
+            :fft      :(AbstractOperators.DFT);
             :rfft     :RDFT;
             :irfft    :IRDFT;
             :ifft     :IDFT;
             :dct      :DCT;
             :idct     :IDCT;
+           ]
+
+importedDSP = [
             :conv     :Conv;
             :xcorr    :Xcorr;
             :filt     :Filt;
-            :exp      :Exp;
-            :cos      :Cos;
-            :sin      :Sin;
-            :atan     :Atan;
-            :tanh     :Tanh;
            ]
 
-exported = [:finitediff :FiniteDiff;
+exported = [
+            :finitediff :FiniteDiff;
             :variation  :Variation;
             :mimofilt   :MIMOFilt;
             :zeropad    :ZeroPad;
@@ -56,14 +64,26 @@ for f in  imported[:,1]
 		import Base: $f
 	end
 end
+#importing functions from FFTW
+for f in  importedFFTW[:,1]
+	@eval begin
+		import FFTW: $f
+	end
+end
+#importing functions from DSP
+for f in  importedDSP[:,1]
+	@eval begin
+		import DSP: $f
+	end
+end
 #exporting functions
 for f in  exported[:,1]
 	@eval begin
 		export $f
 	end
 end
 
-fun = [imported; exported]
+fun = [imported; importedFFTW; importedDSP; exported]
 for i = 1:size(fun,1)
 	f,fAbsOp = fun[i,1],fun[i,2]
 	@eval begin

src/syntax/expressions/addition.jl

@@ -95,7 +95,7 @@ function Usum_op(xA::NTuple{N,Variable},
 		 A::L1,
 		 B::AbstractOperator,sign::Bool) where {N, M, L1<:HCAT{M,N}}
 	if xB[1] in xA
-		idx = findfirst(xA.==xB[1])
+        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]  )
@@ -113,7 +113,7 @@ function Usum_op(xA::Tuple{Variable},
 		 A::AbstractOperator,
 		 B::L2,sign::Bool) where {N, M, L2<:HCAT{M,N}}
 	if xA[1] in xB
-		idx = findfirst(xA.==xB[1])
+        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]  )
@@ -207,9 +207,8 @@ end
 # sum with array/scalar
 
 #broadcasted + -
-import Base: broadcast
 
-function broadcast(::typeof(+),a::AbstractExpression, b::AbstractExpression)
+function Broadcast.broadcasted(::typeof(+),a::AbstractExpression, b::AbstractExpression)
 	A = convert(Expression,a)
 	B = convert(Expression,b)
 	if size(affine(A),1) != size(affine(B),1)
@@ -225,7 +224,7 @@ function broadcast(::typeof(+),a::AbstractExpression, b::AbstractExpression)
 	return A+B
 end
 
-function broadcast(::typeof(-),a::AbstractExpression, b::AbstractExpression)
+function Broadcast.broadcasted(::typeof(-),a::AbstractExpression, b::AbstractExpression)
 	A = convert(Expression,a)
 	B = convert(Expression,b)
 	if size(affine(A),1) != size(affine(B),1)