Revert "Updates for Julia 1.0 (#102)" (#104)

This reverts commit b4a40ae.

Author: dpsanders

.travis.yml

@@ -6,13 +6,13 @@ os:
   - osx
 
 julia:
-  - 0.7
-  - 1.0
+  - 0.5
+  - 0.6
   - nightly
 
 matrix:
   allow_failures:
-    - julia: nightly
+    - julia: 0.5
 
 
 notifications:

REQUIRE

@@ -1,5 +1,6 @@
-julia 0.7
-IntervalArithmetic 0.15
-IntervalRootFinding 0.4
-IntervalContractors 0.3
-MacroTools 0.4.4
+julia 0.6 0.7
+IntervalArithmetic 0.9 0.14
+IntervalRootFinding 0.2 0.3
+IntervalContractors 0.2 0.3
+MacroTools 0.3
+

appveyor.yml

@@ -1,18 +1,9 @@
 environment:
   matrix:
-  - julia_version: 0.7
-  - julia_version: 1
-  - julia_version: nightly
-
-platform:
-  - x86 # 32-bit
-  - x64 # 64-bit
-
-# # Uncomment the following lines to allow failures on nightly julia
-# # (tests will run but not make your overall status red)
-# matrix:
-#   allow_failures:
-#   - julia_version: nightly
+  - JULIAVERSION: "julialang/bin/winnt/x86/0.4/julia-0.4-latest-win32.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x64/0.4/julia-0.4-latest-win64.exe"
+  - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
+  - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
 
 branches:
   only:
@@ -26,18 +17,18 @@ notifications:
     on_build_status_changed: false
 
 install:
-  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
+# Download most recent Julia Windows binary
+  - ps: (new-object net.webclient).DownloadFile(
+        $("http://s3.amazonaws.com/"+$env:JULIAVERSION),
+        "C:\projects\julia-binary.exe")
+# Run installer silently, output to C:\projects\julia
+  - C:\projects\julia-binary.exe /S /D=C:\projects\julia
 
 build_script:
-  - echo "%JL_BUILD_SCRIPT%"
-  - C:\julia\bin\julia -e "%JL_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(), \"ConstraintPropagation\"); Pkg.build(\"ConstraintPropagation\")"
 
 test_script:
-  - 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%"
+  - C:\projects\julia\bin\julia --check-bounds=yes -e "Pkg.test(\"ConstraintPropagation\")"

src/IntervalConstraintProgramming.jl

@@ -2,11 +2,9 @@ __precompile__()
 
 module IntervalConstraintProgramming
 
-using IntervalArithmetic,
-      IntervalRootFinding,
-      IntervalContractors
-
-using Random
+using   IntervalArithmetic,
+        IntervalRootFinding,
+        IntervalContractors
 
 using MacroTools
 
@@ -22,15 +20,9 @@ export
     SubPaving, Paving,
     pave, refine!,
     Vol,
-    show_code,
-    icp, icp!,
-    Constraint
+    show_code
 
 const reverse_operations = IntervalContractors.reverse_operations
-const ARRAY_TYPES = (:AbstractArray, :AbstractVector, :AbstractMatrix, :Array, :Vector, :Matrix)
-const REAL_TYPES = (:Bool, :Integer, :(Irrational{:e}), :(Irrational{:π}), :Rational, :BigFloat, :BigInt, :AbstractFloat, :Real)
-const FUNCTIONS = ((:Base, :+, 2), (:Base, :/, 2), (:Base, :^, 2), (:Base, :asin, 1), (:Base, :cos, 1), (:Base, :exp, 1), (:Base, :*, 2), (:Base, :abs, 1), (:Base, :log, 1), (:Base, :-, 2), (:Base, :sqrt, 1), (:Base, :tan, 1), (:Base, :sin, 1), )
-# ^(x::Interval{Float64}, p::Integer) = pow(x, p)
 
 include("ast.jl")
 include("code_generation.jl")
@@ -41,10 +33,4 @@ include("setinversion.jl")
 include("volume.jl")
 include("functions.jl")
 
-include("tape/tape.jl")
-include("tape/Config.jl")
-include("tape/tracked.jl")
-include("tape/operations.jl")
-include("tape/icp.jl")
-
 end # module

src/ast.jl

@@ -1,7 +1,7 @@
 const symbol_numbers = Dict{Symbol, Int}()
 
 
-"""Return a new, unique symbol like _z3_"""
+doc"""Return a new, unique symbol like _z3_"""
 function make_symbol(s::Symbol)  # default is :z
 
     i = get(symbol_numbers, s, 0)
@@ -17,7 +17,7 @@ end
 make_symbol(c::Char) = make_symbol(Symbol(c))
 
 let current_symbol = 'a'
-    global function make_symbol()
+    function make_symbol()
         current_sym = current_symbol
 
         if current_sym < 'z'
@@ -36,7 +36,7 @@ function make_symbols(n::Integer)
 end
 
 # The following function is not used
-"""Check if a symbol like `:a` has been uniqued to `:_a_1_`"""
+doc"""Check if a symbol like `:a` has been uniqued to `:_a_1_`"""
 function isuniqued(s::Symbol)
     ss = string(s)
     contains(ss, "_") && isdigit(ss[end-1])
@@ -46,21 +46,21 @@ end
 
 # Combine Assignment and FunctionAssignment ?
 
-struct Assignment
+immutable Assignment
     lhs
     op
     args
 end
 
-struct FunctionAssignment
+immutable FunctionAssignment
     f  # function name
     args  # input arguments
     return_arguments
     intermediate  # tuple of intermediate variables
 end
 
 # Close to single assignment form
-mutable struct FlatAST
+type FlatAST
     top  # topmost variable(s)
     input_variables::Set{Symbol}
     intermediate::Vector{Symbol}  # generated vars
@@ -103,17 +103,18 @@ function flatten(ex)
 end
 
 
-# TODO: Parameters
-# numbers:
-
-"""`flatten!` recursively converts a Julia expression into a "flat" (one-dimensional)
+doc"""`flatten!` recursively converts a Julia expression into a "flat" (one-dimensional)
 structure, stored in a FlatAST object. This is close to SSA (single-assignment form,
 https://en.wikipedia.org/wiki/Static_single_assignment_form).
 
 Variables that are found are considered `input_variables`.
 Generated variables introduced at intermediate nodes are stored in
 `intermediate`.
 Returns the variable at the top of the current piece of the tree."""
+
+# TODO: Parameters
+
+# numbers:
 function flatten!(flatAST::FlatAST, ex)
     return ex  # nothing to do to the AST; return the number
 end
@@ -126,7 +127,6 @@ end
 
 
 function flatten!(flatAST::FlatAST, ex::Expr)
-    #@show ex
     local top
 
     if ex.head == :$    # constants written as $a
@@ -163,6 +163,7 @@ end
 """A block represents a linear sequence of Julia statements.
 They are processed in order.
 """
+
 function process_block!(flatAST::FlatAST, ex)
     local top
 

src/code_generation.jl

@@ -1,7 +1,7 @@
-"""
+doc"""
 A generated function, with the code that generated it
 """
-struct GeneratedFunction{F}
+immutable GeneratedFunction{F}
     f::F
     code::Expr
 end
@@ -10,7 +10,7 @@ end
 
 # GeneratedFunction(code::Expr) = GeneratedFunction(eval(code), code)
 
-(f::GeneratedFunction{F})(x...) where {F} = f.f(x...)
+(f::GeneratedFunction{F}){F}(x...) = f.f(x...)
 
 
 function make_tuple(args)
@@ -179,7 +179,7 @@ function forward_backward(flatAST::FlatAST)
 end
 
 
-"""
+doc"""
 Generate code for an anonymous function with given
 input arguments, output arguments, and code block.
 """

src/contractor.jl

@@ -1,9 +1,9 @@
 
+doc"""
+`Contractor` represents a `Contractor` from $\mathbb{R}^N$ to $\mathbb{R}^N$.
+Nout is the output dimension of the forward part.
 """
-`Contractor` represents a contractor from ``\\mathbb{R}^N`` to ``\\mathbb{R}^N``.
-`Nout` is the output dimension of the forward part.
-"""
-struct Contractor{N, Nout, F1<:Function, F2<:Function}
+immutable Contractor{N, Nout, F1<:Function, F2<:Function}
     variables::Vector{Symbol}  # input variables
     forward::GeneratedFunction{F1}
     backward::GeneratedFunction{F2}
@@ -32,7 +32,7 @@ function Contractor(variables::Vector{Symbol}, top, forward, backward, expressio
     Contractor{N, Nout, typeof(forward.f), typeof(backward.f)}(variables, forward, backward, expression)
 end
 
-function Base.show(io::IO, C::Contractor{N,Nout,F1,F2}) where {N,Nout,F1,F2}
+function Base.show{N,Nout,F1,F2}(io::IO, C::Contractor{N,Nout,F1,F2})
     println(io, "Contractor in $(N) dimensions:")
     println(io, "  - forward pass contracts to $(Nout) dimensions")
     println(io, "  - variables: $(C.variables)")
@@ -41,8 +41,8 @@ end
 
 
 
-function (C::Contractor{N,Nout,F1,F2})(
-    A::IntervalBox{Nout,T}, X::IntervalBox{N,T}) where {N,Nout,F1,F2,T}
+function (C::Contractor{N,Nout,F1,F2}){N,Nout,F1,F2,T}(
+    A::IntervalBox{Nout,T}, X::IntervalBox{N,T})
 
     output, intermediate = C.forward(X)
 
@@ -67,7 +67,7 @@ function (C::Contractor{N,Nout,F1,F2})(
 end
 
 # allow 1D contractors to take Interval instead of IntervalBox for simplicty:
-(C::Contractor{N,1,F1,F2})(A::Interval{T}, X::IntervalBox{N,T}) where {N,F1,F2,T} = C(IntervalBox(A), X) 
+(C::Contractor{N,1,F1,F2}){N,F1,F2,T}(A::Interval{T}, X::IntervalBox{N,T}) = C(IntervalBox(A), X)
 
 function make_contractor(expr::Expr)
     # println("Entering Contractor(ex) with ex=$ex")
@@ -109,7 +109,7 @@ function make_contractor(expr::Expr)
 end
 
 
-"""Usage:
+doc"""Usage:
 ```
 C = @contractor(x^2 + y^2)
 A = -∞..1  # the constraint interval

src/functions.jl

@@ -1,10 +1,10 @@
 
 
-"""
+doc"""
 A `ConstraintFunction` contains the created forward and backward
 code
 """
-mutable struct ConstraintFunction{F<:Function, G<:Function}
+type ConstraintFunction{F <: Function, G <: Function}
     input::Vector{Symbol}  # input arguments for forward function
     output::Vector{Symbol} # output arguments for forward function
     forward::F
@@ -14,15 +14,15 @@ mutable struct ConstraintFunction{F<:Function, G<:Function}
     expression::Expr
 end
 
-function Base.show(io::IO, f::ConstraintFunction{F,G}) where {F,G}
+function Base.show{F,G}(io::IO, f::ConstraintFunction{F,G})
     println(io, "ConstraintFunction:")
     println(io, "  - input arguments: $(f.input)")
     println(io, "  - output arguments: $(f.output)")
     print(io, "  - expression: $(MacroTools.striplines(f.expression))")
 end
 
 
-struct FunctionArguments
+immutable FunctionArguments
     input
     return_arguments
     intermediate
@@ -32,12 +32,13 @@ end
 
 const registered_functions = Dict{Symbol, FunctionArguments}()
 
-# TODO: This docstring doesn't work
-# """
-# `@function` registers a function to be used in forwards and backwards mode.
-#
-# Example: `@function f(x, y) = x^2 + y^2`
-# """
+
+@doc """
+`@function` registers a function to be used in forwards and backwards mode.
+
+Example: `@function f(x, y) = x^2 + y^2`
+"""  # this docstring does not work!
+
 @eval macro ($(:function))(ex)   # workaround to define macro @function
 
     (f, args, code) = match_function(ex)
@@ -57,6 +58,8 @@ const registered_functions = Dict{Symbol, FunctionArguments}()
     # flatAST.intermediate = [return_arguments; flatAST.intermediate]
 
 
+
+
     forward, backward = forward_backward(flatAST)
 
     registered_functions[f] = FunctionArguments(