Merge pull request #3843 from JuliaReach/auto-juliaformatter-pr

Automatic JuliaFormatter.jl run

Author: schillic

src/Interfaces/LazySet.jl

@@ -162,15 +162,16 @@ vertices of `X` can be obtained.
 """
 function triangulate(X::LazySet; algorithm::String="delaunay", kwargs...)
     if algorithm == "delaunay"
-        require(@__MODULE__, :MiniQhull, fun_name="triangulate")
+        require(@__MODULE__, :MiniQhull; fun_name="triangulate")
         return _triangulate_delaunay(X; kwargs...)
     else
         throw(ArgumentError("unknown algorithm $algorithm"))
     end
 end
 
 function triangulate_faces(X)
-    require(@__MODULE__, :Polyhedra, fun_name="triangulate_faces")
+    require(@__MODULE__, :Polyhedra; fun_name="triangulate_faces")
+    throw(ArgumentError("`triangulate_faces` not implemented for $(typeof(X))"))
 end
 
 """

src/Sets/VPolygon/minkowski_sum.jl

@@ -14,5 +14,5 @@ sorted in counter-clockwise fashion and has linear complexity ``O(m+n)``, where
 """
 function minkowski_sum(P::VPolygon, Q::VPolygon)
     R = _minkowski_sum_vrep_2d(P.vertices, Q.vertices)
-    return VPolygon(R, apply_convex_hull=false)
+    return VPolygon(R; apply_convex_hull=false)
 end

test/LazyOperations/AffineMap.jl

@@ -88,7 +88,6 @@ for N in [Float64, Rational{Int}, Float32]
     M = N[0 0;]
     @test_throws DimensionMismatch volume(M * B + N[1])
 
-
     # ==================================
     # Type-specific methods
     # ==================================

test/Sets/Polygon.jl

@@ -190,9 +190,9 @@ for N in [Float64, Float32, Rational{Int}]
                                     [N[2, -2], N[6, 0], N[8, 2],
                                      N[8, 4], N[6, 6], N[2, 8]])
 
-        P = VPolygon([N[0, -1], N[2, 0], N[1, 1], N[0, 1]], apply_convex_hull=false)
-        Q1 = VPolygon([N[0, 1], N[0, -1]], apply_convex_hull=false)
-        Q2 = VPolygon([N[0, 1], N[0, -1]], apply_convex_hull=false)
+        P = VPolygon([N[0, -1], N[2, 0], N[1, 1], N[0, 1]]; apply_convex_hull=false)
+        Q1 = VPolygon([N[0, 1], N[0, -1]]; apply_convex_hull=false)
+        Q2 = VPolygon([N[0, 1], N[0, -1]]; apply_convex_hull=false)
         PQ1 = minkowski_sum(P, Q1)
         PQ2 = minkowski_sum(P, Q2)
         @test length(PQ1.vertices) == 5
@@ -202,21 +202,21 @@ for N in [Float64, Float32, Rational{Int}]
         @test length(PQ2.vertices) == 5
         @test is_cyclic_permutation(PQ2.vertices,
                                     [N[0, -2], N[2, -1], N[2, 1],
-                                    N[1, 2], N[0, 2]])
+                                     N[1, 2], N[0, 2]])
 
-        P = VPolygon([N[-1, -1], N[2, 0], N[2, 1], N[0, 1]], apply_convex_hull=false)
-        Q1 = VPolygon([N[0, 1], N[0, -1]], apply_convex_hull=false)
-        Q2 = VPolygon([N[0, -1], N[0, 1]], apply_convex_hull=false)
+        P = VPolygon([N[-1, -1], N[2, 0], N[2, 1], N[0, 1]]; apply_convex_hull=false)
+        Q1 = VPolygon([N[0, 1], N[0, -1]]; apply_convex_hull=false)
+        Q2 = VPolygon([N[0, -1], N[0, 1]]; apply_convex_hull=false)
         PQ1 = minkowski_sum(P, Q1)
         PQ2 = minkowski_sum(P, Q2)
         @test length(PQ1.vertices) == 5
         @test is_cyclic_permutation(PQ1.vertices,
                                     [N[-1, -2], N[2, -1], N[2, 2],
-                                    N[0, 2], N[-1, 0]])
+                                     N[0, 2], N[-1, 0]])
         @test length(PQ2.vertices) == 5
         @test is_cyclic_permutation(PQ2.vertices,
                                     [N[-1, -2], N[2, -1], N[2, 2],
-                                    N[0, 2], N[-1, 0]])
+                                     N[0, 2], N[-1, 0]])
 
         # test for different starting points in vertices_list of minkowski sum
         P = VPolygon([N[4, 0], N[6, 2], N[4, 4]])