Fix some deprecation warnings (#465)

* Relax signature of push!(::LineSearchResults, ...)

* Get rid of deprecation warnings

.travis.yml

@@ -3,7 +3,6 @@ os:
     - linux
     - osx
 julia:
-    - 0.5
     - 0.6
     - nightly
 notifications:

REQUIRE

@@ -1,4 +1,4 @@
-julia 0.4
+julia 0.6
 Calculus
 DualNumbers
 Compat

src/constraints.jl

@@ -1,12 +1,12 @@
-abstract AbstractConstraints
+abstract type AbstractConstraints end
 
 immutable ConstraintsNone <: AbstractConstraints end
 
 immutable ConstraintsBox{T,N} <: AbstractConstraints
     lower::Array{T,N}
     upper::Array{T,N}
 
-    function ConstraintsBox(l::AbstractArray{T}, u::AbstractArray{T})
+    function ConstraintsBox{T,N}(l::AbstractArray{T,N}, u::AbstractArray{T,N}) where {T,N}
         size(l) == size(u) || error("The sizes of the bounds must match")
         for i = 1:length(l)
             l[i] <= u[i] || error("The lower bound must be smaller than the upper bound")
@@ -26,8 +26,8 @@ immutable ConstraintsL{T,M<:AbstractMatrix,N} <: AbstractConstraints
     scratch2::Array{T,N}
     scratch3::Array{T,N}
 
-    function ConstraintsL(A, l::Array{T,N}, u::Array{T,N},
-                          scratch1 = similar(l), scratch2 = similar(l), scratch3 = Array{T}(ndims(l) == 1 ? size(A, 2) : (size(A,2),size(l,2))))
+    function ConstraintsL{T,M,N}(A, l::Array{T,N}, u::Array{T,N},
+                          scratch1 = similar(l), scratch2 = similar(l), scratch3 = Array{T}(ndims(l) == 1 ? size(A, 2) : (size(A,2),size(l,2)))) where {T,M,N}
         size(A, 1) == size(l,1) == size(u,1) || error("The sizes of the bounds must match the size of A")
         for i = 1:length(l)
             l[i] <= u[i] || error("The lower bound must be smaller than the upper bound")
@@ -45,7 +45,7 @@ immutable ConstraintsNL{T,F<:Union{Function,DifferentiableFunction,TwiceDifferen
     lower::Vector{T}
     upper::Vector{T}
 
-    function ConstraintsNL(funcs::Vector, l::AbstractVector{T}, u::AbstractVector{T})
+    function ConstraintsNL{T,F}(funcs::Vector, l::AbstractVector{T}, u::AbstractVector{T}) where {T,F}
         size(A, 1) == length(l) == length(u) || error("The sizes of the bounds must match the ")
         for i = 1:length(l)
             l[i] <= u[i] || error("The lower bound must be smaller than the upper bound")

src/interior.jl

@@ -258,7 +258,7 @@ function interior_newton{T}(objective::TwiceDifferentiableFunction,
         f_x /= t
         @newtontrace
         alphamax = toedge(x, s, constraints)
-        alpha = alphamax < 1 ? 0.9*alphamax : 1.0
+        alpha = alphamax < 1 ? T(0.9*alphamax) : T(1.0)
         alpha, _f_calls, _g_calls =
             hz_linesearch!(df, x, s, xtmp, gr, lsr, alpha, true, constraints, alphamax)
         copy!(x_previous, x)
@@ -297,10 +297,10 @@ function interior_newton{T}(objective::TwiceDifferentiableFunction,
                                         (x,gr) -> combined_fg!(x, gr, objective.fg!, constraints, t))
         end
     end
-    MultivariateOptimizationResults("Interior/Newton",
+    MultivariateOptimizationResults{T,1}("Interior/Newton",
                                     initial_x,
                                     x,
-                                    @compat(Float64(f_x)),
+                                    f_x,
                                     iteration,
                                     iteration == iterations,
                                     x_converged,
@@ -329,10 +329,10 @@ function interior{T}(objective::Union{DifferentiableFunction, TwiceDifferentiabl
     if isnan(t)
         vo, vc, gogo, gogc = gnorm(objective, constraints, initial_x)
         if isfinite(vo) && isfinite(vc) && sqrt(gogo) < grtol
-            return MultivariateOptimizationResults("Interior",
+            return MultivariateOptimizationResults{T,ndims(initial_x)}("Interior",
                                     initial_x,
                                     initial_x,
-                                    @compat(Float64(vo)),
+                                    vo,
                                     0,
                                     false,
                                     false,

src/problems/constrained.jl

@@ -3,7 +3,7 @@ module ConstrainedProblems
 using Optim, Compat
 
 immutable ConstrainedProblem{C<:Optim.AbstractConstraints}
-    name::Compat.ASCIIString
+    name::String
     f::Function
     g!::Function
     h!::Function
@@ -14,7 +14,7 @@ immutable ConstrainedProblem{C<:Optim.AbstractConstraints}
     istwicedifferentiable::Bool
 end
 
-pexamples = Dict{Compat.ASCIIString, ConstrainedProblem}()
+pexamples = Dict{String, ConstrainedProblem}()
 
 #####################################
 ###

src/problems/unconstrained.jl

@@ -3,7 +3,7 @@ module UnconstrainedProblems
 using Compat
 
 immutable OptimizationProblem
-    name::Compat.ASCIIString
+    name::String
     f::Function
     g!::Function
     h!::Function
@@ -13,7 +13,7 @@ immutable OptimizationProblem
     istwicedifferentiable::Bool
 end
 
-examples = Dict{Compat.ASCIIString, OptimizationProblem}()
+examples = Dict{String, OptimizationProblem}()
 
 ##########################################################################
 ###

src/types.jl

@@ -6,11 +6,11 @@ immutable OptimizationState
 end
 
 function OptimizationState(i::Integer, f::Real)
-    OptimizationState(int(i), @compat(Float64(f)), NaN, Dict())
+    OptimizationState(int(i), Float64(f), NaN, Dict())
 end
 
 function OptimizationState(i::Integer, f::Real, g::Real)
-    OptimizationState(int(i), @compat(Float64(f)), @compat(Float64(g)), Dict())
+    OptimizationState(int(i), Float64(f), Float64(g), Dict())
 end
 
 immutable OptimizationTrace
@@ -19,10 +19,10 @@ end
 
 OptimizationTrace() = OptimizationTrace(Vector{OptimizationState}(0))
 
-abstract OptimizationResults
+abstract type OptimizationResults end
 
 type MultivariateOptimizationResults{T,N} <: OptimizationResults
-    method::Compat.ASCIIString
+    method::String
     initial_x::Array{T,N}
     minimum::Array{T,N}
     f_minimum::Float64
@@ -40,7 +40,7 @@ type MultivariateOptimizationResults{T,N} <: OptimizationResults
 end
 
 type UnivariateOptimizationResults{T} <: OptimizationResults
-    method::Compat.ASCIIString
+    method::String
     initial_lower::T
     initial_upper::T
     minimum::T
@@ -204,7 +204,7 @@ LineSearchResults{T}(::Type{T}) = LineSearchResults(T[], T[], T[], 0)
 
 Base.length(lsr::LineSearchResults) = length(lsr.alpha)
 
-function Base.push!{T}(lsr::LineSearchResults{T}, a::T, v::T, d::T)
+function Base.push!(lsr::LineSearchResults, a, v, d)
     push!(lsr.alpha, a)
     push!(lsr.value, v)
     push!(lsr.slope, d)