Add whitespace around some operators and after commas

ararslan · ararslan · commit ec260627a760 · 2018-11-07T19:11:09.000-08:00
diff --git a/src/atoms/affine/multiply_divide.jl b/src/atoms/affine/multiply_divide.jl
@@ -164,10 +164,10 @@ function conic_form!(x::DotMultiplyAtom, unique_conic_forms::UniqueConicForms=Un
         # and that the sizes are compatible,
         # so if the sizes aren't equal the smaller one is size 1
         var = x.children[2]
-        if size(var,1) < size(coeff,1)
-            var = ones(size(coeff,1))*var
-        elseif size(var,2) < size(coeff,2)
-            var = var*ones(1,size(coeff,1))
+        if size(var, 1) < size(coeff, 1)
+            var = ones(size(coeff, 1)) * var
+        elseif size(var, 2) < size(coeff, 2)
+            var = var * ones(1, size(coeff, 1))
         end
 
         const_multiplier = spdiagm(0 => vec(coeff))
@@ -180,10 +180,10 @@ end
 function broadcasted(::typeof(*), x::Constant, y::AbstractExpr)
     if x.size == (1, 1) || y.size == (1, 1)
         return x * y
-    elseif size(y,1) < size(x,1) && size(y,1) == 1
-        return DotMultiplyAtom(x, ones(size(x,1))*y)
-    elseif size(y,2) < size(x,2) && size(y,2) == 1
-        return DotMultiplyAtom(x, y*ones(1,size(x,1)))
+    elseif size(y, 1) < size(x, 1) && size(y, 1) == 1
+        return DotMultiplyAtom(x, ones(size(x, 1)) * y)
+    elseif size(y, 2) < size(x, 2) && size(y, 2) == 1
+        return DotMultiplyAtom(x, y * ones(1, size(x, 1)))
     else
         return DotMultiplyAtom(x, y)
     end
diff --git a/src/atoms/exp_cone/entropy.jl b/src/atoms/exp_cone/entropy.jl
@@ -20,7 +20,7 @@ mutable struct EntropyAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function EntropyAtom(x::AbstractExpr)
-        if sign(x)==ComplexSign()
+        if sign(x) == ComplexSign()
             error("The argument should be real but it's instead complex")
         else
             children = (x,)
@@ -53,9 +53,9 @@ function conic_form!(e::EntropyAtom, unique_conic_forms::UniqueConicForms=Unique
         t = Variable(e.size)
         x = e.children[1]
         objective = conic_form!(t, unique_conic_forms)
-        for i=1:size(x,1)
-            for j=1:size(x,2)
-                conic_form!( ExpConstraint(t[i,j], x[i,j], 1), unique_conic_forms)
+        for i = 1:size(x, 1)
+            for j = 1:size(x, 2)
+                conic_form!(ExpConstraint(t[i, j], x[i, j], 1), unique_conic_forms)
             end
         end
         cache_conic_form!(unique_conic_forms, e, objective)
diff --git a/src/atoms/exp_cone/exp.jl b/src/atoms/exp_cone/exp.jl
@@ -18,7 +18,7 @@ struct ExpAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function ExpAtom(x::AbstractExpr)
-        if sign(x)==ComplexSign()
+        if sign(x) == ComplexSign()
             error("The argument should be real but it's instead complex")
         else
             children = (x,)
diff --git a/src/atoms/exp_cone/logsumexp.jl b/src/atoms/exp_cone/logsumexp.jl
@@ -19,7 +19,7 @@ struct LogSumExpAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function LogSumExpAtom(x::AbstractExpr)
-        if sign(x)==ComplexSign()
+        if sign(x) == ComplexSign()
             error("The argument should be real but it's instead complex")
         else
             children = (x,)
@@ -48,7 +48,7 @@ logsumexp(x::AbstractExpr) = LogSumExpAtom(x)
 
 function conic_form!(e::LogSumExpAtom, unique_conic_forms::UniqueConicForms=UniqueConicForms())
     if !has_conic_form(unique_conic_forms, e)
-        # log(sum(exp(x))) <= t  <=>    sum(exp(x)) <= exp(t) <=> sum(exp(x - t)) <= 1
+        # log(sum(exp(x))) <= t  <=>  sum(exp(x)) <= exp(t) <=> sum(exp(x - t)) <= 1
         t = Variable(e.size)
         z = sum(exp(e.children[1] - t))
         objective = conic_form!(t, unique_conic_forms)
@@ -62,8 +62,8 @@ end
 
 function logisticloss(e::AbstractExpr)
     s = 0
-    length(e)==1 && return logsumexp([e, 0])
-    for i=1:length(e)
+    length(e) == 1 && return logsumexp([e, 0])
+    for i = 1:length(e)
         s += logsumexp([e[i]; 0])
     end
     return s
diff --git a/src/atoms/exp_cone/relative_entropy.jl b/src/atoms/exp_cone/relative_entropy.jl
@@ -17,7 +17,7 @@ struct RelativeEntropyAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function RelativeEntropyAtom(x::AbstractExpr, y::AbstractExpr)
-        if sign(x)==ComplexSign() || sign(y)==ComplexSign()
+        if sign(x) == ComplexSign() || sign(y) == ComplexSign()
             error("Both the arguments should be real but these are instead $(sign(x)) and $(sign(y))")
         else
             children = (x, y)
diff --git a/src/atoms/lp_cone/abs.jl b/src/atoms/lp_cone/abs.jl
@@ -49,8 +49,8 @@ function conic_form!(x::AbsAtom, unique_conic_forms::UniqueConicForms=UniqueConi
                 conic_form!(t[i]>=norm2([real(c[i]);imag(c[i])]), unique_conic_forms)
             end
         else
-            conic_form!(c<=t, unique_conic_forms)
-            conic_form!(c>=-t, unique_conic_forms)
+            conic_form!(c <= t, unique_conic_forms)
+            conic_form!(c >= -t, unique_conic_forms)
         end
         cache_conic_form!(unique_conic_forms, x, objective)
     end
diff --git a/src/atoms/lp_cone/dotsort.jl b/src/atoms/lp_cone/dotsort.jl
@@ -18,7 +18,7 @@ struct DotSortAtom <: AbstractExpr
     w::Value
 
     function DotSortAtom(x::AbstractExpr, w::Value)
-        if sign(x)==ComplexSign()
+        if sign(x) == ComplexSign()
             error("Argument should be real instead it is $(sign(x))")
         else
             if !(length(w) == get_vectorized_size(x))
@@ -32,17 +32,17 @@ struct DotSortAtom <: AbstractExpr
 end
 
 function sign(x::DotSortAtom)
-    if all(x.w.>=0)
+    if all(x.w .>= 0)
         return sign(x.children[1])
-    elseif all(x.w.<=0)
+    elseif all(x.w .<= 0)
         return sign(x.children[1])
     else
         return NoSign()
     end
 end
 
 function monotonicity(x::DotSortAtom)
-    if all(x.w.>=0)
+    if all(x.w .>= 0)
         return (Nondecreasing(), )
     else
         return (NoMonotonicity(), )
diff --git a/src/atoms/lp_cone/max.jl b/src/atoms/lp_cone/max.jl
@@ -16,7 +16,7 @@ struct MaxAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function MaxAtom(x::AbstractExpr, y::AbstractExpr)
-        if sign(x)==ComplexSign() || sign(y)==ComplexSign()
+        if sign(x) == ComplexSign() || sign(y) == ComplexSign()
             error("Both the arguments should be real instead they are $(sign(x)) and $(sign(y))")
         else
             if x.size == y.size
diff --git a/src/atoms/lp_cone/min.jl b/src/atoms/lp_cone/min.jl
@@ -16,7 +16,7 @@ struct MinAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function MinAtom(x::AbstractExpr, y::AbstractExpr)
-        if sign(x)==ComplexSign() || sign(y)==ComplexSign()
+        if sign(x) == ComplexSign() || sign(y) == ComplexSign()
             error("Both the arguments should be real instead they are $(sign(x)) and $(sign(y))")
         else
             if x.size == y.size
diff --git a/src/atoms/lp_cone/minimum.jl b/src/atoms/lp_cone/minimum.jl
@@ -15,7 +15,7 @@ struct MinimumAtom <: AbstractExpr
     size::Tuple{Int, Int}
 
     function MinimumAtom(x::AbstractExpr)
-        if sign(x)==ComplexSign()
+        if sign(x) == ComplexSign()
             error("Argument should be real instead it is $(sign(x))")
         else
             children = (x,)
diff --git a/src/atoms/lp_cone/sumlargest.jl b/src/atoms/lp_cone/sumlargest.jl
@@ -16,7 +16,7 @@ struct SumLargestAtom <: AbstractExpr
     k::Int
 
     function SumLargestAtom(x::AbstractExpr, k::Int)
-        if sign(x)==ComplexSign()
+        if sign(x) == ComplexSign()
             error("Argument should be real instead it is $(sign(x))")
         else
             if k <= 0
diff --git a/src/atoms/sdp_cone/lambda_min_max.jl b/src/atoms/sdp_cone/lambda_min_max.jl
@@ -17,9 +17,9 @@ struct LambdaMaxAtom <: AbstractExpr
 
     function LambdaMaxAtom(x::AbstractExpr)
         children = (x,)
-        m,n = size(x)
-        if m==n
-            return new(:lambdamax, hash(children), children, (1,1))
+        m, n = size(x)
+        if m == n
+            return new(:lambdamax, hash(children), children, (1, 1))
         else
             error("lambdamax can only be applied to a square matrix.")
         end
@@ -70,8 +70,8 @@ struct LambdaMinAtom <: AbstractExpr
 
     function LambdaMinAtom(x::AbstractExpr)
         children = (x,)
-        m,n = size(x)
-        if m==n
+        m, n = size(x)
+        if m == n
             return new(:lambdamin, hash(children), children, (1,1))
         else
             error("lambdamin can only be applied to a square matrix.")
diff --git a/src/atoms/sdp_cone/sumlargesteigs.jl b/src/atoms/sdp_cone/sumlargesteigs.jl
@@ -18,8 +18,8 @@ struct SumLargestEigs <: AbstractExpr
 
     function SumLargestEigs(x::AbstractExpr, k::AbstractExpr)
         children = (x, k)
-        m,n = size(x)
-        if m==n
+        m, n = size(x)
+        if m == n
             return new(:sumlargesteigs, hash(children), children, (1,1))
         else
             error("sumlargesteigs can only be applied to a square matrix.")
diff --git a/src/atoms/second_order_cone/geomean.jl b/src/atoms/second_order_cone/geomean.jl
@@ -11,7 +11,7 @@ struct GeoMeanAtom <: AbstractExpr
     function GeoMeanAtom(x::AbstractExpr, y::AbstractExpr)
         if x.size != y.size
             error("geo mean must take two arguments of the same size")
-        elseif sign(x)==ComplexSign() || sign(y)==ComplexSign()
+        elseif sign(x) == ComplexSign() || sign(y) == ComplexSign()
             error("Both the arguments should be real instead they are $(sign(x)) and $(sign(y))")
         else
             children = (x, y)
diff --git a/src/problems.jl b/src/problems.jl
@@ -145,7 +145,7 @@ function conic_problem(p::Problem)
             for (id, val) in constraint.objs[i]
                 if id == objectid(:constant)
                     for l in 1:sz
-                        b[constr_index + l] = val[1][l]==0 ? val[2][l] : val[1][l]
+                        b[constr_index + l] = val[1][l] == 0 ? val[2][l] : val[1][l]
                     end
                     #b[constr_index + sz + 1 : constr_index + 2*sz] = val[2]
                 else
diff --git a/src/solution.jl b/src/solution.jl
@@ -36,7 +36,7 @@ function solve!(problem::Problem;
     # populate the status, the primal (and possibly dual) solution
     # and the primal (and possibly dual) variables with values
     populate_solution!(m, problem, var_to_ranges, conic_constraints)
-    if !(problem.status==:Optimal) && verbose
+    if problem.status != :Optimal && verbose
         @warn "Problem status $(problem.status); solution may be inaccurate."
     end
 end
@@ -54,7 +54,7 @@ function set_warmstart!(m::MathProgBase.AbstractConicModel,
                 Warmstart may be ineffective."
          primal = zeros(n)
      end
-     if !(length(primal) == n)
+     if length(primal) != n
          @warn "Unable to use cached solution to warmstart problem.
                 (Perhaps the number of variables or constraints in the problem have changed since you last solved it?)
                 Warmstart may be ineffective."
@@ -81,7 +81,7 @@ function load_problem!(m::MathProgBase.AbstractConicModel, c, A, b, cones, varty
     MathProgBase.loadproblem!(m, vec(Array(c)), A, vec(Array(b)), cones, var_cones)
 
     # add integer and binary constraints on variables
-    if !all(Bool[t==:Cont for t in vartypes])
+    if !all(==(:Cont), vartypes)
         try
             MathProgBase.setvartype!(m, vartypes)
         catch
diff --git a/src/variable.jl b/src/variable.jl
@@ -31,23 +31,23 @@ mutable struct Variable <: AbstractExpr
     Variable(size::Int, sets::Symbol...) = Variable((size, 1), sets...)
 end
 
-Semidefinite(m::Integer) = Variable((m,m), :Semidefinite)
+Semidefinite(m::Integer) = Variable((m, m), :Semidefinite)
 function Semidefinite(m::Integer, n::Integer)
-    if m==n
-        return Variable((m,m), :Semidefinite)
+    if m == n
+        return Variable((m, m), :Semidefinite)
     else
         error("Semidefinite matrices must be square")
     end
 end
 
-ComplexVariable(m::Int, n::Int, sets::Symbol...) = Variable((m,n), ComplexSign(), sets...)
+ComplexVariable(m::Int, n::Int, sets::Symbol...) = Variable((m, n), ComplexSign(), sets...)
 ComplexVariable(sets::Symbol...) = Variable((1, 1), ComplexSign(), sets...)
 ComplexVariable(size::Tuple{Int, Int}, sets::Symbol...) = Variable(size, ComplexSign(), sets...)
 ComplexVariable(size::Int, sets::Symbol...) = Variable((size, 1), ComplexSign(), sets...)
-HermitianSemidefinite(m::Integer) = ComplexVariable((m,m), :Semidefinite)
+HermitianSemidefinite(m::Integer) = ComplexVariable((m, m), :Semidefinite)
 function HermitianSemidefinite(m::Integer, n::Integer)
-    if m==n
-        return ComplexVariable((m,m), :Semidefinite)
+    if m == n
+        return ComplexVariable((m, m), :Semidefinite)
     else
         error("HermitianSemidefinite matrices must be square")
     end
