codac4matlab 2.0.0.dev25__cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

codac4matlab/tests/test_Color.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Simon Rohou, Maël Godard
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+
+class TestColor(unittest.TestCase):
+  
+  def test_Color(self):
+
+    # Red
+
+    d_rgb = [255, 0, 0]
+    d_rgba = [255, 0, 0, 255]
+    d_hsv = [0, 100, 100]
+    d_hsva = [0, 100, 100, 100]
+
+    colors = [
+      Color(d_rgb, Model.RGB),
+      Color(d_rgba, Model.RGB),
+      Color(d_hsv, Model.HSV),
+      Color(d_hsva, Model.HSV),
+      Color("#FF0000")
+    ]
+
+    for c in colors:
+      self.assertTrue(Approx(c.rgb().vec(), 1.0)==Color([255, 0, 0]).rgb().vec())
+      self.assertTrue(Approx(c.rgb().vec(), 1.0)==Color([255, 0, 0, 255]).rgb().vec())
+      self.assertTrue(Approx(c.hsv().vec(), 1.0)==Color([0, 100, 100],Model.HSV).hsv().vec())
+      self.assertTrue(Approx(c.hsv().vec(), 1.0)==Color([0, 100, 100, 100],Model.HSV).hsv().vec())
+
+    # Pink full opacity
+
+    d_rgb = [229,128,255]
+    d_rgba = [229,128,255,255]
+    d_hsv = [288,50,100]
+    d_hsva = [288,50,100,100]
+
+    colors = [
+      Color(d_rgb, Model.RGB),
+      Color(d_rgba, Model.RGB),
+      Color(d_hsv, Model.HSV),
+      Color(d_hsva, Model.HSV),
+      Color("#E580FF")
+    ]
+
+    for c in colors:
+      self.assertTrue(Approx(c.rgb().vec(), 1.0)==Color([229,128,255]).rgb().vec())
+      self.assertTrue(Approx(c.rgb().vec(), 1.0)==Color([229,128,255,255]).rgb().vec())
+      self.assertTrue(Approx(c.hsv().vec(), 1.0)==Color([288,50,100],Model.HSV).hsv().vec())
+      self.assertTrue(Approx(c.hsv().vec(), 1.0)==Color([288,50,100,100],Model.HSV).hsv().vec())
+
+    # Pink 40% opacity
+
+    a_rgb=102
+    a_hsv=40
+    d_rgba = [229,128,255,a_rgb]
+    d_hsva = [288,50,100,a_hsv]
+
+    colors = [
+      Color(d_rgba, Model.RGB),
+      Color(d_hsva, Model.HSV),
+      Color("#E580FF66")
+    ]
+    for c in colors:
+      self.assertTrue(Approx(c.rgb().vec(), 1.0)==Color([229,128,255,a_rgb]).rgb().vec())
+      self.assertTrue(Approx(c.hsv().vec(), 1.0)==Color([288,50,100,a_hsv],Model.HSV).hsv().vec())
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_ConvexPolygon.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Simon Rohou
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestConvexPolygon(unittest.TestCase):
+
+  def test_ConvexPolygon_degenerate_base(self):
+
+    p = ConvexPolygon([[1,2],[1,2]])
+    self.assertTrue(len(p.vertices()) == 1)
+
+    p = ConvexPolygon([[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+    self.assertTrue(len(convex_hull([[1,2],[1,2],[1,2]])) == 1)
+    p = ConvexPolygon([[1,2],[1,2],[1,2]])
+    self.assertTrue(len(p.vertices()) == 1)
+
+    p = ConvexPolygon([[1,2],[1,3]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,2]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,3],[1,2]])
+    self.assertTrue(len(p.vertices()) == 2)
+
+  def test_ConvexPolygon_degenerate_cases(self):
+
+    p1 = ConvexPolygon([[0,4]])
+    self.assertTrue(len(p1.edges()) == 1)
+    self.assertTrue(p1.edges()[0][0] == IntervalVector([0,4]))
+    self.assertTrue(p1.edges()[0][1] == IntervalVector([0,4]))
+
+    p1 = ConvexPolygon([[0,4],[2,8]])
+    self.assertTrue(len(p1.edges()) == 1)
+    self.assertTrue(p1.edges()[0][0] == IntervalVector([0,4]))
+    self.assertTrue(p1.edges()[0][1] == IntervalVector([2,8]))
+    self.assertTrue(p1 == ConvexPolygon([[2,8],[0,4]]))
+
+  def test_ConvexPolygon_intersection(self):
+
+    p1 = ConvexPolygon([[0,4],[4,8],[7,0]])
+    p2 = ConvexPolygon([[-1,2],[-1,3],[5,3],[5,2]])
+    self.assertTrue((p1 & p2) == ConvexPolygon([
+        [3.5,2],[5,2],[5,3],[1.75,3]
+      ]))
+
+    p1 = ConvexPolygon([[3,2],[1,6],[6,5]])
+    p2 = ConvexPolygon(IntervalVector([[0,4],[0,4]]))
+    self.assertTrue((p1 & p2) == ConvexPolygon([
+        [3,2],[2,4],[4,4],[4,3]
+      ]))
+  
+    p1 = ConvexPolygon([[1,2],[3,4],[5,1],[2,1]])
+    p2 = ConvexPolygon(IntervalVector([[2,6],[2,6]]))
+    self.assertTrue(Approx(p1 & p2) == ConvexPolygon([
+        [2,2],[2,3],[3,4],[4.+1./3.,2.]
+      ]))
+
+    # Big box
+    p1 = ConvexPolygon([[1,2],[3,4],[5,1],[2,1]])
+    p2 = ConvexPolygon(IntervalVector([[-10,10],[-10,10]]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    # Inner box
+    p1 = ConvexPolygon([[1,2],[3,4],[5,1],[2,1]])
+    p2 = ConvexPolygon(IntervalVector([[2.8,3],[2.8,3]]))
+    self.assertTrue((p1 & p2) == p2) # same box
+
+    p1 = ConvexPolygon([[2,1],[3,1],[4,2],[4,3],[3,4],[2,4],[1,3],[1,2]])
+    p2 = ConvexPolygon(IntervalVector([[1,4],[1,4]]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    # Shifted polygon points declaration
+    p1 = ConvexPolygon([[3,4],[2,4],[1,3],[1,2],[2,1],[3,1],[4,2],[4,3]])
+    p2 = ConvexPolygon(IntervalVector([[1,4],[1,4]]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    # Degenerate case
+    p1 = ConvexPolygon([[4000,200]])
+    p2 = ConvexPolygon(IntervalVector([4000,200]))
+    self.assertTrue(p1.box() == IntervalVector([4000,200]))
+    self.assertTrue(p2.box() == IntervalVector([4000,200]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon(IntervalVector([[2,6],[1,5]]))
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[2,1.2],[6,2],[6,4.8],[2,4]]))
+    self.assertTrue(len(q.edges()) == 4)
+    self.assertTrue(len(q.vertices()) == 4)
+
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon(IntervalVector([[3,5],[1,5]]))
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[3,1.4],[5,1.8],[5,4.6],[3,4.2]]))
+    self.assertTrue(len(q.edges()) == 4)
+    self.assertTrue(len(q.vertices()) == 4)
+
+    # Degenerated box
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon(IntervalVector([[4],[1,5]]))
+
+    self.assertTrue(p1.edges()[0] == Segment([[1,1],[6,2]]))
+    self.assertTrue(p1.edges()[1] == Segment([[6,2],[7,5]]))
+    self.assertTrue(p1.edges()[2] == Segment([[7,5],[2,4]]))
+    self.assertTrue(p1.edges()[3] == Segment([[2,4],[1,1]]))
+    self.assertTrue(len(p1.edges()) == 4)
+
+    self.assertTrue(p2.edges()[0] == Segment([[4,1],[4,5]]))
+    self.assertTrue(len(p2.edges()) == 1)
+
+    self.assertTrue((p1.edges()[1] & p2.edges()[0]) == IntervalVector.empty(2))
+    self.assertTrue(Approx(p1.edges()[0] & p2.edges()[0]) == IntervalVector([4,1.6]))
+    self.assertTrue((p1.edges()[3] & p2.edges()[0]) == IntervalVector.empty(2))
+    self.assertTrue(Approx(p1.edges()[2] & p2.edges()[0]) == IntervalVector([4,4.4]))
+
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[4,4.4],[4,1.6]]))
+    self.assertTrue(len(q.vertices()) == 2)
+
+    # Degenerated polygon
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[4,1],[4,5]])
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[4,4.4],[4,1.6]]))
+    self.assertTrue(len(q.vertices()) == 2)
+
+    # Point intersection
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[2,4],[-4,4],[0,8]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon([[2,4]]))
+    self.assertTrue(len(q.vertices()) == 1)
+
+    # Point intersection, line polygon
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[2,4],[-4,4]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon([[2,4]]))
+    self.assertTrue(len(q.vertices()) == 1)
+
+    # Empty intersection
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[5,1.5],[8,2],[8,0],[5,0]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(len(q.vertices()) == 0)
+    self.assertTrue(q.is_empty())
+
+    # Empty intersection, degenerate case
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[5,1.5],[80,2]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(len(q.vertices()) == 0)
+    self.assertTrue(q.is_empty())
+
+    # Intersection of empty polygons
+    p1 = ConvexPolygon.empty()
+    p2 = ConvexPolygon.empty()
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(q.is_empty())
+
+    # Intersection of a polygon and one empty polygon
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon.empty()
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(q.is_empty())
+
+    # Intersection of a polygon and one empty polygon (line)
+    p1 = ConvexPolygon([[5,1.5],[80,2]])
+    p2 = ConvexPolygon.empty()
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(q.is_empty())
+
+    # Other test with inflated points
+    p1 = ConvexPolygon(IntervalVector([[-4,4],[-3,3]]))
+    a1,a2 = IntervalVector([-4,-6]), IntervalVector([-4,6])
+    a1.inflate(1e-10)
+    a2.inflate(1e-10)
+    p2 = ConvexPolygon([Segment(a1,a2)])
+    q = p1 & p2
+    self.assertTrue(len(q.edges()) == 1)
+    self.assertTrue(Approx(q.edges()[0][0],1e-5) == IntervalVector([-4,-3]))
+    self.assertTrue(Approx(q.edges()[0][1],1e-5) == IntervalVector([-4,3]))
+
+    # Parallel edges
+    p1 = ConvexPolygon([
+      [-1,-10],
+      [3,-10],
+      [3,1],
+      [-1,6],
+    ])
+    p2 = ConvexPolygon([
+      [-1,10],
+      [-1,-1],
+      [3,-6],
+      [3,10],
+    ])
+    q = p1 & p2
+    self.assertTrue(q == ConvexPolygon([
+      [3,-6],
+      [3,1],
+      [-1,6],
+      [-1,-1],
+    ]))
+
+    # Parallel edges towards infinity
+    p1 = ConvexPolygon([
+      [-1,next_float(-oo)],
+      [3,next_float(-oo)],
+      [3,1],
+      [-1,6],
+    ])
+    p2 = ConvexPolygon([
+      [-1,prev_float(oo)],
+      [-1,-1],
+      [3,-6],
+      [3,prev_float(oo)],
+    ])
+    q = p1 & p2
+    self.assertTrue(q == ConvexPolygon([
+      [3,-6],
+      [3,1],
+      [-1,6],
+      [-1,-1],
+    ]))
+
+    p1 = ConvexPolygon([[4,3.5],[5,4],[4,4.5]])
+    p2 = ConvexPolygon([[4,3.5],[5,3.5],[5,4.25],[4.5,4.25],[4,4]])
+    self.assertTrue(Approx(p1 & p2) == ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]]))
+
+    p1 = ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]])
+    p2 = ConvexPolygon(IntervalVector([[4,5],[4.1]]))
+    self.assertTrue(Approx(p1 & p2, 1e-10) == ConvexPolygon(IntervalVector([[4.2,4.8],[4.1]])))
+
+    p1 = ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]])
+    p2 = ConvexPolygon(IntervalVector([[4,5],Interval(41)/10]))
+    self.assertTrue(Approx(p1 & p2, 1e-10) == ConvexPolygon(IntervalVector([[4.2,4.8],Interval(41)/10])))
+
+    p1 = ConvexPolygon([
+      IntervalVector([[0.0999999, 0.100001],[0.989016, 0.989017]]),
+      IntervalVector([[0.0999999, 0.100001],[1.0015, 1.00151]]),
+      IntervalVector([[0, 0],[0.999999, 1]]),
+      IntervalVector([[0, 0],[1, 1.00001]])
+    ])
+
+    p2 = ConvexPolygon([
+      IntervalVector([[0, 0],[0.987514, 0.987515]]),
+      IntervalVector([[0.1, 0.100001],[0.989016, 0.989017]]),
+      IntervalVector([[0.1, 0.100001],[1.0015, 1.00151]]),
+      IntervalVector([[0, 0],[1.01248, 1.01249]]),
+    ])
+
+    self.assertTrue(Approx(p1 & p2, 1e-5) == ConvexPolygon([
+      [[0.0997289, 0.100002],[0.989016, 0.989938]],
+      [[0.0995829, 0.100002],[1.00059, 1.00151]],
+      [[0, 0],[0.999547, 1.00047]]
+    ]))
+
+    p1 &= p2
+
+    m = IntervalVector([6.5,1])
+    p1 = ConvexPolygon(m)
+    p2 = ConvexPolygon([
+      [[6.49999, 6.50001],[0.759358, 0.759359]],
+      [[6.49999, 6.50001],[1.19382, 1.19383]],
+      [[6.4, 6.40001],[1.20537, 1.20538]],
+      [[6.4, 6.40001],[0.78097, 0.780971]],
+    ])
+
+    s = Segment(IntervalVector([[6.49999, 6.50001],[0.759358, 0.759359]]), IntervalVector([[6.49999, 6.50001],[1.19382, 1.19383]]))
+    self.assertTrue(s.contains(m) == BoolInterval.UNKNOWN)
+    self.assertTrue((p1 & p2) == ConvexPolygon([m]))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcAction.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Simon Rohou
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestCtcAction(unittest.TestCase):
+  
+  def test_CtcAction(self):
+    
+    x = VectorVar(2)
+    c1 = CtcInverse(AnalyticFunction([x], x-IntervalVector([[1,5],[8,6]])), IntervalVector([[0],[0]]))
+
+    b = IntervalVector(2)
+    c1.contract(b)
+    self.assertTrue(b == IntervalVector([[1,5],[8,6]]))
+
+    c2 = CtcAction(c1, [2,-1])
+    b = IntervalVector(2)
+    c2.contract(b)
+    self.assertTrue(b == IntervalVector([[8,6],[-5,1]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcCartProd.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Simon Rohou
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestCtcCartProd(unittest.TestCase):
+  
+  def test_CtcCartProd(self):
+    
+    v = VectorVar(1)
+    c1 = CtcInverse(AnalyticFunction([v], v), IntervalVector([[-1,1]]))
+    c2 = CtcInverse(AnalyticFunction([v], v), IntervalVector([[5,6]]))
+
+    a = IntervalVector(1)
+    b = IntervalVector(1)
+    c1.contract(a)
+    self.assertTrue(a == IntervalVector([[-1,1]]))
+    c2.contract(b)
+    self.assertTrue(b == IntervalVector([[5,6]]))
+
+    x = IntervalVector(2)
+    c3 = CtcCartProd(c1,c2)
+    c3.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[5,6]]))
+
+    y = IntervalVector(2)
+    c4 = cart_prod(c1,c2)
+    c4.contract(y)
+    self.assertTrue(y == IntervalVector([[-1,1],[5,6]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcCtcBoundary.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Simon Rohou
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+def test_inside_diamond(x):
+  if (x[1] < x[0]+1) and (x[1] > x[0]-1) and (x[1] < -x[0]+1) and (x[1] > -x[0]-1):
+    return BoolInterval.TRUE
+  elif not(x[1] < x[0]+1) or not(x[1] > x[0]-1) or not(x[1] < -x[0]+1) or not(x[1] > -x[0]-1):
+    return BoolInterval.FALSE
+  else:
+    return BoolInterval.UNKNOWN
+
+class TestCtcCtcBoundary(unittest.TestCase):
+
+  def test_CtcCtcBoundary(self):
+
+    ctc_bound_diamond = CtcSegment([[-1],[0]], [[0],[-1]]) | CtcSegment([[0],[-1]], [[1],[0]]) \
+      | CtcSegment([[1],[0]], [[0],[1]]) | CtcSegment([[0],[1]], [[-1],[0]])
+
+    ctc_diamond = CtcCtcBoundary(ctc_bound_diamond,test_inside_diamond)
+    #DefaultFigure.pave(IntervalVector([[-2,2],[-2,2]]), ctc_diamond, 0.1)
+
+    x = IntervalVector(2)
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+
+    x = IntervalVector([[0,10],[0,10]])
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[0,1],[0,1]]))
+
+    x = IntervalVector([[0.2,10],[0.2,10]])
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[0.2,0.8],[0.2,0.8]]))
+
+    x = IntervalVector([[0.5,10],[0.5,10]])
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[0.5],[0.5]]))
+
+if __name__ ==  '__main__':
+  unittest.main()