Multi-dimensional functions (#44)

* Parametrize Separators

* Fix test

* Fixes for the types of lhs and args

* Multi-dimensional contractor seems to be working!

* Make multidim iterated functions work

* Remove debugging output for iterated functions

* Move parse_comparison to separator.jl

* Escape name of contractor when creating constraint so that it is available with name _C_1_ etc.

* Convenience constructor for ConstraintSeparator that automatically extracts variables

* Factor out content of  into make_constraint function

* Parametrise interval field of ConstraintSeparator

Author: dpsanders

src/ast.jl

@@ -139,7 +139,7 @@ end
 # function process_iterated_function!(flatAST::FlattenedAST, ex)
 
 function process_tuple!(flatAST::FlattenedAST, ex)
-    println("Entering process_tuple")
+    # println("Entering process_tuple")
     # @show flatAST
     # @show ex
     # top_args = [flatten!(flatAST, arg) for arg in ex.args]
@@ -161,19 +161,36 @@ The name a is currently retained.
 TODO: It should later be made unique.
 """
 function process_assignment!(flatAST::FlattenedAST, ex)
-    println("process_assignment!:")
-    # @show ex
-    # @show ex.args[1], ex.args[2]
+    # println("process_assignment!:")
+    #  @show ex
+    #  @show ex.args[1], ex.args[2]
 
     top = flatten!(flatAST, ex.args[2])
+    # @show top
 
     var = ex.args[1]
-    push!(flatAST.intermediate, var)
+    # @show var
+
+    # TODO: Replace the following by multiple dispatch
+    if isa(var, Expr) && var.head == :tuple
+        vars = [var.args...]
+
+    elseif isa(var, Tuple)
+        vars = [var...]
+
+    elseif isa(var, Vector)
+        vars = var
+
+    else
+        vars = [var]
+    end
+
+    append!(flatAST.intermediate, vars)
 
-    top_level_code = Assignment(var, :(), top)  # empty operation
+    top_level_code = Assignment(vars, :(), top)  # empty operation
     push!(flatAST.code, top_level_code)
 
-    # @show flatAST
+    # j@show flatAST
 
     return var
 
@@ -183,17 +200,23 @@ end
 by rewriting it to the equivalent set of iterated functions"""
 function process_iterated_function!(flatAST::FlattenedAST, ex)
     total_function_call = ex.args[1]
-    argument = ex.args[2]
+    args = ex.args[2:end]
+
+    # @show args
 
     function_name = total_function_call.args[2]
     power = total_function_call.args[3]  # assumed integer
 
-    new_expr = :($function_name($argument))
+    new_expr = :($function_name($(args...)))
+
+    # @show new_expr
 
     for i in 2:power
         new_expr = :($function_name($new_expr))
     end
 
+    # @show new_expr
+
     flatten!(flatAST, new_expr)
 end
 

src/code_generation.jl

@@ -1,5 +1,11 @@
 
 function make_tuple(args)
+
+    if isa(args, Symbol)
+        # args = [args]
+        return args
+    end
+
     length(args) == 1 && return args[1]
 
     return Expr(:tuple, args...)
@@ -10,19 +16,24 @@ function emit_forward_code(a::Assignment)
 
     args = isa(a.args, Vector) ? a.args : [a.args]
 
+    lhs = make_tuple(a.lhs)
+
     if a.op == :()  # empty
-        :($(a.lhs) = $(args...) )
+        args = make_tuple(args)
+        :($lhs = $args)
 
     else
-        :($(a.lhs) = $(a.op)($(args...) ) )
+        :($lhs = $(a.op)($(args...) ) )
     end
 end
 
 
 function emit_forward_code(a::FunctionAssignment)
     f = a.func
-    args = make_tuple(a.lhs)
-    :($args = $(esc(f)).forward($(a.args...) ) )
+    args = isa(a.args, Vector) ? a.args : [a.args]
+    lhs = make_tuple(a.lhs)
+
+    :($lhs = $(esc(f)).forward($(a.args...) ) )
 end
 
 
@@ -43,7 +54,10 @@ function emit_backward_code(a::Assignment)
     rev_op = rev_ops[a.op]  # find reverse operation
 
     if rev_op == :()   # empty
-        return :($(args...) = $(a.lhs))
+        args = make_tuple(args)
+        lhs = make_tuple(a.lhs)
+        return :($args = $lhs)
+        #return :($(args...) = $(a.lhs))
     else
         rev_code = :($(rev_op)($(return_args...)))
     end

src/contractor.jl

@@ -136,6 +136,15 @@ function make_contractor(ex::Expr)
         # using an IntervalBox and intersection of IntervalBoxes
     end
 
+    top_args = make_tuple(top)
+
+    local intersect_code
+
+    if isa(top_args, Symbol)
+        intersect_code = :($top_args = $top_args ∩ _A_)  # check type stability
+    else
+        intersect_code = :($top_args = IntervalBox($top_args) ∩ _A_)  # check type stability
+    end
 
 
     code =
@@ -147,7 +156,7 @@ function make_contractor(ex::Expr)
 
                 $(forward_output) = forward($(forward.input_arguments...))
 
-                $(top) = $(top) ∩ _A_
+                $intersect_code
 
                 $(backward_output) = backward($(backward.input_arguments...))
 
@@ -157,10 +166,10 @@ function make_contractor(ex::Expr)
 
         end
 
-    # @show forward
-    # @show backward
-    #
-    # @show code
+    #  @show forward
+    #  @show backward
+    # #
+    #  @show code
 
     return :(Contractor($(augmented_input_arguments),
                         $(Meta.quot(expr)),

src/functions.jl

@@ -26,6 +26,8 @@ type ConstraintFunction{F <: Function, G <: Function}
     output::Vector{Symbol} # output arguments for forward function
     forward::F
     backward::G
+    forward_code::Expr
+    backward_code::Expr
 end
 
 type FunctionArguments
@@ -92,14 +94,19 @@ Example: `@function f(x, y) = x^2 + y^2`
 
     registered_functions[f] = FunctionArguments(flatAST.variables, flatAST.intermediate, return_arguments)
 
+    forward_function = make_function(forward_code)
+    backward_function = make_function(backward_code)
 
     return quote
         #$(esc(Meta.quot(f))) = ConstraintFunction($(all_vars), $(generated), $(forward_code), $(backward_code))
         #$(esc(f)) =
         $(esc(f)) =
             ConstraintFunction($(flatAST.variables),
                                 $(flatAST.intermediate),
-                                $(make_function(forward_code)), $(make_function(backward_code))
+                                $(forward_function),
+                                $(backward_function),
+                                $(Meta.quot(forward_function)),
+                                $(Meta.quot(backward_function))
                                 )
 
 

src/separator.jl

@@ -6,20 +6,22 @@ ConstraintSeparator is a separator that represents a constraint defined directly
 using `@constraint`.
 """
 # CHANGE TO IMMUTABLE AND PARAMETRIZE THE FUNCTION FOR EFFICIENCY
-type ConstraintSeparator <: Separator
+type ConstraintSeparator{C, II} <: Separator
     variables::Vector{Symbol}
     #separator::Function
-    constraint::Interval
-    contractor::Contractor
+    constraint::II  # Interval or IntervalBox
+    contractor::C
     expression::Expr
 end
 
+ConstraintSeparator(constraint, contractor, expression) = ConstraintSeparator(contractor.variables[2:end], constraint, contractor, expression)
+
 doc"""CombinationSeparator is a separator that is a combination (union, intersection,
 or complement) of other separators.
 """
-type CombinationSeparator <: Separator
+type CombinationSeparator{F} <: Separator
     variables::Vector{Symbol}
-    separator::Function
+    separator::F
     expression::Expr
 end
 
@@ -50,11 +52,69 @@ end
 
 
 
+doc"""`parse_comparison` parses comparisons like `x >= 10`
+into the corresponding interval, expressed as `x ∈ [10,∞]`
 
+Returns the expression and the constraint interval
+
+TODO: Allow something like [3,4]' for the complement of [3,4]
+"""
+
+function parse_comparison(ex)
+    expr, limits =
+    @match ex begin
+       ((a_ <= b_) | (a_ < b_) | (a_ ≤ b_))   => (a, (-∞, b))
+       ((a_ >= b_) | (a_ > b_) | (a_ ≥ b_))   => (a, (b, ∞))
+
+       ((a_ == b_) | (a_ = b_))   => (a, (b, b))
+
+       ((a_ <= b_ <= c_)
+        | (a_ < b_ < c_)
+        | (a_ <= b_ < c)
+        | (a_ < b_ <= c))         => (b, (a, c))
+
+       ((a_ >= b_ >= c_)
+       | (a_ > b_ > c_)
+       | (a_ >= b_ > c_)
+       | (a_ > b_ >= c))          => (b, (c, a))
+
+       ((a_ ∈ [b_, c_])
+       | (a_ in [b_, c_])
+       | (a_ ∈ b_ .. c_)
+       | (a_ in b_ .. c_))        => (a, (b, c))
+
+       _                          => (ex, (-∞, ∞))
+
+   end
+
+   a, b = limits
+
+   return (expr, a..b)   # expr ∈ [a,b]
+
+end
 
-macro constraint(ex::Expr)  # alternative name for constraint -- remove?
-    # @show ex
-    expr, constraint = parse_comparison(ex)
+
+function new_parse_comparison(ex)
+    @show ex
+    if @capture ex begin
+            (op_(a_, b_))
+        end
+
+        #return (op, a, b)
+        @show op, a, b
+
+    elseif ex.head == :comparison
+        println("Comparison")
+        symbols = ex.args[1:2:5]
+        operators = ex.args[2:2:4]
+
+        @show symbols
+        @show operators
+
+    end
+end
+
+function make_constraint(expr, constraint)
 
     if isa(expr, Symbol)
         expr = :(1 * $expr)  # make into an expression!
@@ -65,15 +125,24 @@ macro constraint(ex::Expr)  # alternative name for constraint -- remove?
     full_expr = Meta.quot(:($expr ∈ $constraint))
 
     code = quote end
-    push!(code.args, :($contractor_name = @contractor($(esc(expr)))))
-    push!(code.args, :(ConstraintSeparator($(contractor_name).variables[2:end], $constraint, $contractor_name, $full_expr)))
+    push!(code.args, :($(esc(contractor_name)) = @contractor($(esc(expr)))))
+    # push!(code.args, :(ConstraintSeparator($(esc(contractor_name)).variables[2:end], $constraint, $(esc(contractor_name)), $full_expr)))
+
+    push!(code.args, :(ConstraintSeparator($constraint, $(esc(contractor_name)), $full_expr)))
 
     # @show code
 
     code
+end
+
+macro constraint(ex::Expr)  # alternative name for constraint -- remove?
+    # @show ex
+    expr, constraint = parse_comparison(ex)
 
+    make_constraint(expr, constraint)
 end
 
+
 # doc"""Create a separator from a given constraint expression, written as
 # standard Julia code.
 #

test/runtests.jl

@@ -30,7 +30,7 @@ end
     X = IntervalBox(II, II)
     S = @constraint x^2 + y^2 <= 1
 
-    @test typeof(S) == IntervalConstraintProgramming.ConstraintSeparator
+    @test typeof(S) <: IntervalConstraintProgramming.ConstraintSeparator
 
     inner, outer = S(X)
     @test inner == (-1..1, -1..1)
@@ -158,3 +158,21 @@ end
 
     @test C3(A, x) == sqrt(A / 16)
 end
+
+@testset "Multidimensional functions" begin
+
+    @function g4(x, y) = (2x, 2y)
+
+    A = IntervalBox(0.5..1, 0.5..1)
+    x = y = 0..1
+
+    C4 = @contractor g4(x, y)
+
+    @test IntervalBox(C4(A, x, y)) == A / 2
+
+
+    C5 = @contractor (g4↑2)(x, y)
+
+    @test IntervalBox(C5(A, x, y)) == A / 4
+
+end