Add Support for Julia v1.0 (#24)

* add julia v0.8, v1.0 and v1.1 to travis
* julia v1.0 passing
* compat for julia v0.6

Author: ccoffrin

.travis.yml

@@ -4,7 +4,9 @@ os:
   - osx
 julia:
   - 0.6
-  - nightly
+  - 0.7
+  - 1.0
+  - 1.1
 matrix:
   allow_failures:
     - julia: nightly
@@ -14,19 +16,8 @@ cache:
 addons:
   apt_packages:
     - gfortran
-
 before_install:
-    # don't keep an old version of the code in the cache
-  - julia -e 'if "GraphicalModelLearning" in keys(Pkg.installed()) Pkg.rm("GraphicalModelLearning"); Pkg.rm("GraphicalModelLearning") end'
-  - julia -e 'Pkg.update()' #make sure we get the latest version of METADATA
-  - julia -e 'if !("Coverage" in keys(Pkg.installed())) Pkg.add("Coverage") end'
-  - julia -e 'if !("Documenter" in keys(Pkg.installed())) Pkg.add("Documenter") end'
-
-script:
-  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-  - julia -e 'Pkg.clone(pwd())'
-  - julia -e 'Pkg.test("GraphicalModelLearning", coverage=true)'
-
+  - julia -e '(VERSION >= v"0.7" && using Pkg); Pkg.rm("GraphicalModelLearning"); Pkg.rm("GraphicalModelLearning")'
+  - julia -e '(VERSION >= v"0.7" && using Pkg); Pkg.update()'
 after_success:
-  - julia -e  'using Coverage; cd(Pkg.dir("GraphicalModelLearning")); LCOV.writefile("lcov.info", process_folder(".")); run(pipeline(`curl -s https://codecov.io/bash`, `bash`))'
-  - julia -e 'cd(Pkg.dir("GraphicalModelLearning")); include(joinpath("docs", "make.jl"))'
+  - julia -e '(VERSION >= v"0.7" && using Pkg); Pkg.add("Coverage"); cd(Pkg.dir("GraphicalModelLearning")); using Coverage; Codecov.submit(process_folder())'

REQUIRE

@@ -1,7 +1,8 @@
 julia 0.6
 
 JuMP 0.17 0.19-
+MathProgBase
 Ipopt
 StatsBase
 
-Compat 0.17
+Compat 1.0

src/GraphicalModelLearning.jl

@@ -1,5 +1,3 @@
-isdefined(Base, :__precompile__) && __precompile__()
-
 module GraphicalModelLearning
 
 export learn, inverse_ising
@@ -11,73 +9,103 @@ using JuMP
 using MathProgBase # for solver type
 using Ipopt
 
-using Compat # used for julia v0.5 abstract types
+import Compat.LinearAlgebra
+import Compat.LinearAlgebra: diag
+import Compat.Statistics: mean
+
+import Compat.Nothing
+import Compat.undef
+import Compat.@info
+
+if VERSION < v"0.7.0-"
+    function Base.digits(value; base=0, pad=0)
+        if base != 0 && pad != 0
+            return digits(value, base, pad)
+        elseif base != 0
+            return digits(value, base)
+        else
+            return digits(value)
+        end
+    end
+
+    function Base.digits!(array, value; base=0)
+        if base != 0
+            digits!(array, value, base)
+        else
+            digits!(array, value)
+        end
+    end
+end
 
 include("models.jl")
 
 include("sampling.jl")
 
-@compat abstract type GMLFormulation end
+abstract type GMLFormulation end
 
-type multiRISE <: GMLFormulation
+mutable struct multiRISE <: GMLFormulation
     regularizer::Real
     symmetrization::Bool
     interaction_order::Integer
 end
 # default values
 multiRISE() = multiRISE(0.4, true, 2)
 
-type RISE <: GMLFormulation
+mutable struct RISE <: GMLFormulation
     regularizer::Real
     symmetrization::Bool
 end
 # default values
 RISE() = RISE(0.4, true)
 
-type RISEA <: GMLFormulation
+mutable struct RISEA <: GMLFormulation
     regularizer::Real
     symmetrization::Bool
 end
 # default values
 RISEA() = RISEA(0.4, true)
 
-type logRISE <: GMLFormulation
+mutable struct logRISE <: GMLFormulation
     regularizer::Real
     symmetrization::Bool
 end
 # default values
 logRISE() = logRISE(0.8, true)
 
-type RPLE <: GMLFormulation
+mutable struct RPLE <: GMLFormulation
     regularizer::Real
     symmetrization::Bool
 end
 # default values
 RPLE() = RPLE(0.2, true)
 
 
-@compat abstract type GMLMethod end
+abstract type GMLMethod end
 
-type NLP <: GMLMethod
+mutable struct NLP <: GMLMethod
     solver::MathProgBase.AbstractMathProgSolver
 end
 # default values
 NLP() = NLP(IpoptSolver(print_level=0))
 
 
 # default settings
-learn{T <: Real}(samples::Array{T,2}) = learn(samples, RISE(), NLP())
-learn{T <: Real, S <: GMLFormulation}(samples::Array{T,2}, formulation::S) = learn(samples, formulation, NLP())
+learn(samples::Array{T,2}) where T <: Real = learn(samples, RISE(), NLP())
+learn(samples::Array{T,2}, formulation::S) where {T <: Real, S <: GMLFormulation} = learn(samples, formulation, NLP())
 
+if VERSION >= v"0.7.0-"
+    #TODO add better support for Adjoints
+    learn(samples::LinearAlgebra.Adjoint, args...) = learn(copy(samples), args...)
+end
 
-function data_info{T <: Real}(samples::Array{T,2})
+function data_info(samples::Array{T,2}) where T <: Real
     (num_conf, num_row) = size(samples)
     num_spins = num_row - 1
     num_samples = sum(samples[1:num_conf,1])
     return num_conf, num_spins, num_samples
 end
 
-function learn{T <: Real}(samples::Array{T,2}, formulation::multiRISE, method::NLP)
+function learn(samples::Array{T,2}, formulation::multiRISE, method::NLP) where T <: Real
     num_conf, num_spins, num_samples = data_info(samples)
 
     lambda = formulation.regularizer*sqrt(log((num_spins^2)/0.05)/num_samples)
@@ -149,12 +177,12 @@ function learn{T <: Real}(samples::Array{T,2}, formulation::multiRISE, method::N
     return FactorGraph(inter_order, num_spins, :spin, reconstruction) 
 end
 
-function learn{T <: Real}(samples::Array{T,2}, formulation::RISE, method::NLP)
+function learn(samples::Array{T,2}, formulation::RISE, method::NLP) where T <: Real
     num_conf, num_spins, num_samples = data_info(samples)
 
     lambda = formulation.regularizer*sqrt(log((num_spins^2)/0.05)/num_samples)
 
-    reconstruction = Array{Float64}(num_spins, num_spins)
+    reconstruction = Array{Float64}(undef, num_spins, num_spins)
 
     for current_spin = 1:num_spins
         nodal_stat  = [ samples[k, 1 + current_spin] * (i == current_spin ? 1 : samples[k, 1 + i]) for k=1:num_conf , i=1:num_spins]
@@ -205,12 +233,12 @@ function grad_risea_obj(g, var, stat, weight)
     end
 end
 
-function learn{T <: Real}(samples::Array{T,2}, formulation::RISEA, method::NLP)
+function learn(samples::Array{T,2}, formulation::RISEA, method::NLP) where T <: Real
     num_conf, num_spins, num_samples = data_info(samples)
 
     lambda = formulation.regularizer*sqrt(log((num_spins^2)/0.05)/num_samples)
 
-    reconstruction = Array{Float64}(num_spins, num_spins)
+    reconstruction = Array{Float64}(undef, num_spins, num_spins)
 
     for current_spin = 1:num_spins
         nodal_stat  = [ samples[k, 1 + current_spin] * (i == current_spin ? 1 : samples[k, 1 + i]) for k=1:num_conf , i=1:num_spins]
@@ -259,12 +287,12 @@ function learn{T <: Real}(samples::Array{T,2}, formulation::RISEA, method::NLP)
 end
 
 
-function learn{T <: Real}(samples::Array{T,2}, formulation::logRISE, method::NLP)
+function learn(samples::Array{T,2}, formulation::logRISE, method::NLP) where T <: Real
     num_conf, num_spins, num_samples = data_info(samples)
 
     lambda = formulation.regularizer*sqrt(log((num_spins^2)/0.05)/num_samples)
 
-    reconstruction = Array{Float64}(num_spins, num_spins)
+    reconstruction = Array{Float64}(undef, num_spins, num_spins)
 
     for current_spin = 1:num_spins
         nodal_stat  = [ samples[k, 1 + current_spin] * (i == current_spin ? 1 : samples[k, 1 + i]) for k=1:num_conf , i=1:num_spins]
@@ -297,12 +325,12 @@ function learn{T <: Real}(samples::Array{T,2}, formulation::logRISE, method::NLP
 end
 
 
-function learn{T <: Real}(samples::Array{T,2}, formulation::RPLE, method::NLP)
+function learn(samples::Array{T,2}, formulation::RPLE, method::NLP) where T <: Real
     num_conf, num_spins, num_samples = data_info(samples)
 
     lambda = formulation.regularizer*sqrt(log((num_spins^2)/0.05)/num_samples)
 
-    reconstruction = Array{Float64}(num_spins, num_spins)
+    reconstruction = Array{Float64}(undef, num_spins, num_spins)
 
     for current_spin = 1:num_spins
         nodal_stat  = [ samples[k, 1 + current_spin] * (i == current_spin ? 1 : samples[k, 1 + i]) for k=1:num_conf , i=1:num_spins]

src/models.jl

@@ -4,26 +4,28 @@ export FactorGraph, jsondata
 
 alphabets = [:spin, :boolean, :integer, :integer_pos, :real, :real_pos]
 
-type FactorGraph{T <: Real}
+
+mutable struct FactorGraph{T <: Real}
     order::Int
     varible_count::Int
     alphabet::Symbol
     terms::Dict{Tuple,T} # TODO, would be nice to have a stronger tuple type here
-    variable_names::Nullable{Vector{String}}
-    FactorGraph(a,b,c,d,e) = check_model_data(a,b,c,d,e) ? new(a,b,c,d,e) : error("generic init problem")
+    variable_names::Union{Vector{String}, Nothing}
+    #FactorGraph(a,b,c,d,e) = check_model_data(a,b,c,d,e) ? new(a,b,c,d,e) : error("generic init problem")
 end
-FactorGraph{T <: Real}(order::Int, varible_count::Int, alphabet::Symbol, terms::Dict{Tuple,T}) = FactorGraph{T}(order, varible_count, alphabet, terms, Nullable{Vector{String}}())
-FactorGraph{T <: Real}(matrix::Array{T,2}) = convert(FactorGraph{T}, matrix)
-FactorGraph{T <: Real}(dict::Dict{Tuple,T}) = convert(FactorGraph{T}, dict)
+
+FactorGraph(order::Int, varible_count::Int, alphabet::Symbol, terms::Dict{Tuple,T}) where T <: Real = FactorGraph{T}(order, varible_count, alphabet, terms, nothing)
+FactorGraph(matrix::Array{T,2}) where T <: Real = convert(FactorGraph{T}, matrix)
+FactorGraph(dict::Dict{Tuple,T}) where T <: Real = convert(FactorGraph{T}, dict)
 FactorGraph(list::Array{Any,1}) = convert(FactorGraph, list)
 
 
-function check_model_data{T <: Real}(order::Int, varible_count::Int, alphabet::Symbol, terms::Dict{Tuple,T}, variable_names::Nullable{Vector{String}})
+function check_model_data(order::Int, varible_count::Int, alphabet::Symbol, terms::Dict{Tuple,T}, variable_names::Union{Vector{String}, Nothing}) where T <: Real
     if !in(alphabet, alphabets)
         error("alphabet $(alphabet) is not supported")
         return false
     end
-    if !isnull(variable_names) && length(variable_names) != varible_count
+    if variable_names != nothing && length(variable_names) != varible_count
         error("expected $(varible_count) but only given $(length(variable_names))")
         return false
     end
@@ -54,7 +56,7 @@ end
 function Base.show(io::IO, gm::FactorGraph)
     println(io, "alphabet: ", gm.alphabet)
     println(io, "vars: ", gm.varible_count)
-    if !isnull(gm.variable_names)
+    if gm.variable_names != nothing
         println(io, "variable names: ")
         println(io, "  ", get(gm.variable_names))
     end
@@ -65,19 +67,26 @@ function Base.show(io::IO, gm::FactorGraph)
     end
 end
 
-function jsondata{T <: Real}(gm::FactorGraph{T})
+function jsondata(gm::FactorGraph{T}) where T <: Real
     data = []
     for k in sort(collect(keys(gm.terms)), by=(x)->(length(x),x))
         push!(data, Dict("term" => k, "weight" => gm.terms[k]))
     end
     return data
 end
 
-Base.start(gm::FactorGraph) = start(gm.terms)
-Base.next(gm::FactorGraph, state) = next(gm.terms, state)
-Base.done(gm::FactorGraph, state) = done(gm.terms, state)
+
+if VERSION < v"0.7.0-"
+    Base.start(gm::FactorGraph) = start(gm.terms)
+    Base.next(gm::FactorGraph, state) = next(gm.terms, state)
+    Base.done(gm::FactorGraph, state) = done(gm.terms, state)
+else
+    Base.iterate(gm::FactorGraph, kwargs...) = Base.iterate(gm.terms, kwargs...)
+end
+
 
 Base.length(gm::FactorGraph) = length(gm.terms)
+#Base.size(gm::FactorGraph, a...) = size(gm.terms, a...)
 
 Base.getindex(gm::FactorGraph, i) = gm.terms[i]
 Base.keys(gm::FactorGraph) = keys(gm.terms)
@@ -95,15 +104,15 @@ end
 
 diag_key(gm::FactorGraph, i::Int) = tuple(fill(i, gm.order)...)
 
-#Base.diag{T <: Real}(gm::FactorGraph{T}) = [ get(gm.terms, diag_key(gm, i), zero(T)) for i in 1:gm.varible_count ]
+#Base.diag(gm::FactorGraph{T}) where T <: Real = [ get(gm.terms, diag_key(gm, i), zero(T)) for i in 1:gm.varible_count ]
 
-Base.DataFmt.writecsv{T <: Real}(io, gm::FactorGraph{T}, args...; kwargs...) = writecsv(io, convert(Array{T,2}, gm), args...; kwargs...)
+#Base.DataFmt.writecsv(io, gm::FactorGraph{T}, args...; kwargs...) where T <: Real = writecsv(io, convert(Array{T,2}, gm), args...; kwargs...)
 
-Base.convert{T <: Real}(::Type{FactorGraph}, m::Array{T,2}) = convert(FactorGraph{T}, m)
-function Base.convert{T <: Real}(::Type{FactorGraph{T}}, m::Array{T,2})
+Base.convert(::Type{FactorGraph}, m::Array{T,2}) where T <: Real = convert(FactorGraph{T}, m)
+function Base.convert(::Type{FactorGraph{T}}, m::Array{T,2}) where T <: Real
     @assert size(m,1) == size(m,2) #check matrix is square
 
-    info("assuming spin alphabet")
+    @info "assuming spin alphabet"
     alphabet = :spin
     varible_count = size(m,1)
 
@@ -132,7 +141,7 @@ function Base.convert{T <: Real}(::Type{FactorGraph{T}}, m::Array{T,2})
     return FactorGraph(2, varible_count, alphabet, terms)
 end
 
-function Base.convert{T <: Real}(::Type{Array{T,2}}, gm::FactorGraph{T})
+function Base.convert(::Type{Array{T,2}}, gm::FactorGraph{T}) where T <: Real
     if gm.order != 2
         error("cannot convert a FactorGraph of order $(gm.order) to a matrix")
     end
@@ -152,8 +161,8 @@ function Base.convert{T <: Real}(::Type{Array{T,2}}, gm::FactorGraph{T})
 end
 
 
-Base.convert{T <: Real}(::Type{Dict}, m::Array{T,2}) = convert(Dict{Tuple,T}, m)
-function Base.convert{T <: Real}(::Type{Dict{Tuple,T}}, m::Array{T,2})
+Base.convert(::Type{Dict}, m::Array{T,2}) where T <: Real = convert(Dict{Tuple,T}, m)
+function Base.convert(::Type{Dict{Tuple,T}}, m::Array{T,2}) where T <: Real
     @assert size(m,1) == size(m,2) #check matrix is square
 
     varible_count = size(m,1)
@@ -181,7 +190,7 @@ end
 
 
 function Base.convert(::Type{FactorGraph}, list::Array{Any,1})
-    info("assuming spin alphabet")
+    @info "assuming spin alphabet"
     alphabet = :spin
 
     max_variable = 0
@@ -198,15 +207,15 @@ function Base.convert(::Type{FactorGraph}, list::Array{Any,1})
         max_variable = max(max_variable, maximum(term))
     end
 
-    info("dectected $(max_variable) variables with order $(max_order)")
+    @info "dectected $(max_variable) variables with order $(max_order)"
 
     return FactorGraph(max_order, max_variable, alphabet, terms)
 end
 
 
-Base.convert{T <: Real}(::Type{FactorGraph}, dict::Dict{Tuple,T}) = convert(FactorGraph{T}, dict)
-function Base.convert{T <: Real}(::Type{FactorGraph{T}}, dict::Dict{Tuple,T})
-    info("assuming spin alphabet")
+Base.convert(::Type{FactorGraph}, dict::Dict{Tuple,T}) where T <: Real = convert(FactorGraph{T}, dict)
+function Base.convert(::Type{FactorGraph{T}}, dict::Dict{Tuple,T}) where T <: Real
+    @info "assuming spin alphabet"
     alphabet = :spin
 
     max_variable = 0
@@ -217,7 +226,7 @@ function Base.convert{T <: Real}(::Type{FactorGraph{T}}, dict::Dict{Tuple,T})
         max_variable = max(max_variable, maximum(term))
     end
 
-    info("dectected $(max_variable) variables with order $(max_order)")
+    @info "dectected $(max_variable) variables with order $(max_order)"
 
     return FactorGraph(max_order, max_variable, alphabet, dict)
 end