Switch from Assignment[] to Equation[]

Assignment[] and Equation[] do the same thing, and the structs AssignmentPair and AssignmentQuad ended up not being useful. Why not switch to Equation[] to be consistent with ModelingToolkit?

Author: RXGottlieb

src/SourceCodeMcCormick.jl

@@ -8,17 +8,17 @@ abstract type AbstractTransform end
 # ADD documentation for generic function here
 function transform_rule end
 
-struct AssignmentPair
-    l::Assignment
-    u::Assignment
-end
+# struct AssignmentPair
+#     l::Assignment
+#     u::Assignment
+# end
 
-struct AssignmentQuad
-    l::Assignment
-    u::Assignment
-    cv::Assignment
-    cc::Assignment
-end
+# struct AssignmentQuad
+#     l::Assignment
+#     u::Assignment
+#     cv::Assignment
+#     cc::Assignment
+# end
 
 include(joinpath(@__DIR__, "interval", "interval.jl"))
 include(joinpath(@__DIR__, "relaxation", "relaxation.jl"))

src/interval/rules.jl

@@ -9,39 +9,39 @@ using IfElse
 Unitary Rules
 =#
 function transform_rule(::IntervalTransform, nothing, yL, yU, xL, xU)
-    rl = Assignment(yL, xL)
-    ru = Assignment(yU, xU)
-    AssignmentPair(rl, ru)
+    rl = Equation(yL, xL)
+    ru = Equation(yU, xU)
+    return rl, ru
 end
 function transform_rule(::IntervalTransform, ::typeof(exp), yL, yU, xL, xU)
-    rl = Assignment(yL, exp(xL))
-    ru = Assignment(yU, exp(xU))
+    rl = Equation(yL, exp(xL))
+    ru = Equation(yU, exp(xU))
     return rl, ru
 end
 
 #=
 Binary Rules
 =#
 function transform_rule(::IntervalTransform, ::typeof(+), zL, zU, xL, xU, yL, yU)
-    rl = Assignment(zL, xL + yL)
-    ru = Assignment(zU, xU + yU)
+    rl = Equation(zL, xL + yL)
+    ru = Equation(zU, xU + yU)
     return rl, ru
 end
 function transform_rule(::IntervalTransform, ::typeof(-), zL, zU, xL, xU, yL, yU)
-    rl = Assignment(zL, xL - yU)
-    ru = Assignment(zU, xU - yL)
+    rl = Equation(zL, xL - yU)
+    ru = Equation(zU, xU - yL)
     return rl, ru
 end
 function transform_rule(::IntervalTransform, ::typeof(*), zL, zU, xL, xU, yL, yU)
-    rl = Assignment(zL, IfElse.ifelse(yL >= 0.0, 
+    rl = Equation(zL, IfElse.ifelse(yL >= 0.0, 
         IfElse.ifelse(xL >= 0.0, xL*yL,
             IfElse.ifelse(xU <= 0.0, xL*yU, xL*yU)),
         IfElse.ifelse(yU <= 0.0,
             IfElse.ifelse(xL >= 0.0, xU*yL,
                 IfElse.ifelse(xU <= 0.0, xU*yU, xU*yL)),
             IfElse.ifelse(xL > 0.0, xU*yL,
                 IfElse.ifelse(xU < 0.0, xL*yU, min(xU*yL, xU*yU))))))
-    ru = Assignment(zU, IfElse.ifelse(yL >= 0.0, 
+    ru = Equation(zU, IfElse.ifelse(yL >= 0.0, 
         IfElse.ifelse(xL >= 0.0, xU*yU,
             IfElse.ifelse(xU <= 0.0, xU*yL, xU*yU)),
         IfElse.ifelse(yU <= 0.0,
@@ -54,13 +54,13 @@ end
 
 
 function transform_rule(::IntervalTransform, ::typeof(min), zL, zU, xL, xU, yL, yU)
-    rl = Assignment(zL, min(xL, yL))
-    ru = Assignment(zU, min(xU, yU))
+    rl = Equation(zL, min(xL, yL))
+    ru = Equation(zU, min(xU, yU))
     return rl, ru
 end
 function transform_rule(::IntervalTransform, ::typeof(max), zL, zU, xL, xU, yL, yU)
-    rl = Assignment(zL, max(xL, yL))
-    ru = Assignment(zU, max(xU, yU))
+    rl = Equation(zL, max(xL, yL))
+    ru = Equation(zU, max(xU, yU))
     return rl, ru
 end
 

src/relaxation/rules.jl

@@ -27,25 +27,25 @@ Unitary Rules
 function transform_rule(::McCormickTransform, ::typeof(exp), yL, yU, ycv, ycc, xL, xU, xcv, xcc)
     mcv = mid_expr(xcv, xcc, xL)
     mcc = mid_expr(xcv, xcc, xU)
-    rcv = Assignment(ycv, exp(mcv))
-    rcc = Assignment(ycc, line_expr(mcc, xL, xU, yL, yU))
+    rcv = Equation(ycv, exp(mcv))
+    rcc = Equation(ycc, line_expr(mcc, xL, xU, yL, yU))
     return rcv, rcc
 end
 
 #=
 Binary Rules
 =#
 function transform_rule(::McCormickTransform, ::typeof(+), zL, zU, zcv, zcc, xL, xU, xcv, xcc, yL, yU, ycv, ycc)
-    rcv = Assignment(zcv, xcv + ycv)
-    rcc = Assignment(zcc, xcc + ycc)
+    rcv = Equation(zcv, xcv + ycv)
+    rcc = Equation(zcc, xcc + ycc)
     return rcv, rcc
 end
 
 
 # Rules for multiplication adapted from:
 # https://github.com/PSORLab/McCormick.jl/blob/master/src/forward_operators/multiplication.jl
 function transform_rule(::McCormickTransform, ::typeof(*), zL, zU, zcv, zcc, xL, xU, xcv, xcc, yL, yU, ycv, ycc)
-    rcv = Assignment(zcv, IfElse.ifelse(xL >= 0.0,
+    rcv = Equation(zcv, IfElse.ifelse(xL >= 0.0,
         IfElse.ifelse(yL >= 0.0, max(yU*xcv + xU*ycv - xU*yU, yL*xcv + xL*ycv - xL*yL),
             IfElse.ifelse(yU <= 0.0, -max((-yU)*xcv + xU*(-ycv) - xU*(-yU), (-yL)*xcv + xL*(-ycv) - xL*(-yL)), 
                 max(yU*xcv + xU*ycv - xU*yU, yL*xcc + xL*ycv - xL*yL))),
@@ -56,7 +56,7 @@ function transform_rule(::McCormickTransform, ::typeof(*), zL, zU, zcv, zcc, xL,
             IfElse.ifelse(yL >= 0.0, max(xU*ycv + yU*xcv - yU*xU, xL*ycc + yL*xcv - yL*xL),
                 IfElse.ifelse(yU <= 0.0, -max(xU*(-ycv) + (-yU)*xcv - (-yU)*xU, xL*(-ycc) + (-yL)*xcv - (-yL)*xL), 
                     max(yU*xcv + xU*ycv - xU*yU, yL*xcc + xL*ycc - xL*yL))))))
-    rcc = Assignment(zcc, IfElse.ifelse(xL >= 0.0,
+    rcc = Equation(zcc, IfElse.ifelse(xL >= 0.0,
         IfElse.ifelse(yL >= 0.0, min(yL*xcc + xU*ycc - xU*yL, yU*xcc + xU*ycc - xL*yU),
             IfElse.ifelse(yU <= 0.0, -min((-yL)*xcc + xU*(-ycc) - xU*(-yL), (-yU)*xcc + xU*(-ycc) - xL*(-yU)), 
                 min(yL*xcv + xU*ycc - xU*yL, yU*xcc + xL*ycc - xL*yU))),