codac4matlab 2.0.0.dev14__cp313-cp313-win32.whl

codac4matlab/tests/test_Segment.py

@@ -0,0 +1,123 @@
+#!/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 hull(x):
+  if x == -oo:
+    return Interval(-oo, next_float(-oo))
+  if x == oo:
+    return Interval(previous_float(oo), oo)
+  else:
+    return INterval(x)
+
+
+class TestSegment(unittest.TestCase):
+
+  def tests_intersects(self):
+
+    self.assertTrue(Segment([[0,0],[10,0]]).intersects(Segment([[4,0],[6,0]])) == BoolInterval.TRUE)
+    self.assertTrue(Segment([[0,0],[10,0]]).intersects(Segment([[5,0],[15,0]])) == BoolInterval.TRUE)
+    self.assertTrue(Segment([[0,0],[10,0]]).intersects(Segment([[5,-5],[5,10]])) == BoolInterval.TRUE)
+    self.assertTrue(Segment([[0,0],[10,0]]).intersects(Segment([[15,-5],[15,10]])) == BoolInterval.FALSE)
+    self.assertTrue(Segment([[0,0],[10,10]]).intersects(Segment([[1,1],[9,9]])) == BoolInterval.TRUE)
+    self.assertTrue(Segment([[1,1],[9,9]]).intersects(Segment([[0,0],[10,10]])) == BoolInterval.TRUE)
+
+    self.assertTrue(Segment(IntervalVector([hull(-oo),2]),Vector([0,2])).intersects(Segment(Vector([0,0]),Vector([0,1]))) == BoolInterval.FALSE)
+    self.assertTrue(Segment(IntervalVector([hull(-oo),2]),Vector([0,2])).intersects(Segment(Vector([0,0]),Vector([0,2]))) == BoolInterval.TRUE)
+
+  def tests_contains(self):
+
+    p1,p2,p3 = Vector([0.,0.]), Vector([1.5,3.]), Vector([0.,2.])
+    e1 = Segment(Vector([-10.,-10.]), Vector([10.,10.]))
+    e2 = Segment(Vector([1.,1.]), Vector([10.,10.]))
+    e3 = Segment(Vector([0.,0.]), Vector([2.,4.]))
+
+    self.assertTrue(e1.contains(p1) != BoolInterval.FALSE)
+    self.assertTrue(e2.contains(p1) == BoolInterval.FALSE)
+    self.assertTrue(e3.contains(p2) != BoolInterval.FALSE)
+    self.assertTrue(e3.contains(p3) == BoolInterval.FALSE)
+
+  def tests_proj_intersection(self):
+
+    self.assertTrue(proj_intersection([[0,0],[1,1]], [[3,3],[4,4]])
+      == IntervalVector(2))
+
+    self.assertTrue(proj_intersection([[0,0],[1,0]], [[0,2],[1,2]])
+      == IntervalVector.empty(2))
+
+    self.assertTrue(proj_intersection([[2,0],[6,4]],[[6,5],[5,6]])
+      == Approx(IntervalVector([6.5,4.5])))
+
+    self.assertTrue(proj_intersection([[-0.7,0.7],[0,1]], [[-1,0],[-0.7,-0.7]])
+      == Approx(IntervalVector([-1.2069,0.4828]), 1e-4))
+
+    self.assertTrue(proj_intersection([[1,2],[2,3]], [[8,4],[7,4]])
+      == IntervalVector([3,4]))
+
+    self.assertTrue(proj_intersection([[4,11],[8,11]], [[12,12],[12,16]])
+      == IntervalVector([12,11]))
+
+    self.assertTrue(proj_intersection([[1,2],[1,2]], [[8,4],[7,4]])
+      == IntervalVector(2))
+
+    self.assertTrue(proj_intersection([[0,1],[0,2]], [[2,1],[2,2]])
+      == IntervalVector.empty(2))
+
+    self.assertTrue(proj_intersection([[-4,4],[0,0]], [[0,0],[4,4]])
+      == IntervalVector([0,0]))
+
+    self.assertTrue(proj_intersection([[-4,4],[0,0]], [[4,4],[0,0]])
+      == IntervalVector([0,0]))
+
+    self.assertTrue(proj_intersection([[0,4],[4,0]], [[4,4],[0,0]])
+      == IntervalVector([2,2]))
+
+  def tests_intersection(self):
+
+    self.assertTrue((Segment([0,0],[0,0]) & Segment([0,0],[5,0])) == IntervalVector([0,0])) # degenerate line, horizontal edge line
+    self.assertTrue((Segment([0,0],[0,0]) & Segment([0,0],[0,5])) == IntervalVector([0,0])) # degenerate line, vertical edge line
+
+    self.assertTrue((Segment([0,0],[0,1]) & Segment([0,0],[0,5.0])) == IntervalVector([0,[0,1.]])) # vertical edge line (colinear)
+    self.assertTrue((Segment([0,0],[0,1]) & Segment([0,0],[0,0.5])) == IntervalVector([0,[0,0.5]])) # vertical edge line (colinear)
+    self.assertTrue((Segment([0,0],[1,0]) & Segment([0,0],[5.0,0])) == IntervalVector([[0,1.],0])) # horizontal edge line (colinear)
+    self.assertTrue((Segment([0,0],[1,0]) & Segment([0,0],[0.5,0])) == IntervalVector([[0,0.5],0])) # horizontal edge line (colinear)
+
+    self.assertTrue((Segment([7,4],[7,5]) & Segment([7,6],[7,8])) == IntervalVector.empty(2)) # vertical edge line (colinear), no intersection
+    self.assertTrue((Segment([4,7],[5,7]) & Segment([6,7],[8,7])) == IntervalVector.empty(2)) # horizontal edge line (colinear), no intersection
+
+    self.assertTrue((Segment([0,0],[3,0]) & Segment([1,2],[1,-999])) == IntervalVector([1,0])) # perpendicular intersection
+    self.assertTrue((Segment([0.5,-1],[0.5,5]) & Segment([-3,2],[5,2])) == IntervalVector([0.5,2])) # perpendicular intersection
+
+    self.assertTrue((Segment([0,0],[3,0]) & Segment([1,-10],[1,-999])) == IntervalVector.empty(2)) # perpendicular lines, no intersection
+    self.assertTrue((Segment([0.5,-1],[0.5,5]) & Segment([-3,-2],[5,-2])) == IntervalVector.empty(2)) # perpendicular lines, no intersection
+
+    self.assertTrue((Segment([8,4],[9,2]) & Segment([7,3],[9,3])) == IntervalVector([8.5,3])) # perpendicular oblique lines
+    self.assertTrue((Segment([8,4],[9,2]) & Segment([8.5,8],[8.5,0])) == IntervalVector([8.5,3])) # perpendicular oblique lines
+
+    self.assertTrue((Segment([8,4],[9,2]) & Segment([7.,3],[7.5,3])) == IntervalVector.empty(2)) # secant oblique lines, no intersection
+    self.assertTrue((Segment([8,4],[9,2]) & Segment([8.5,8],[8.5,7])) == IntervalVector.empty(2)) # secant oblique lines, no intersection
+    self.assertTrue((Segment([6,-1],[8,1]) & Segment([7.5,0],[9,0])) == IntervalVector.empty(2)) # secant oblique lines, no intersection
+    self.assertTrue((Segment([6,-1],[8,1]) & Segment([6.5,0.5],[6.5,2])) == IntervalVector.empty(2)) # secant oblique lines, no intersection
+  
+    # Other tests
+    self.assertTrue((Segment([8,14],[6,13]) & Segment([1,1],[1,14])) == IntervalVector.empty(2))
+    self.assertTrue((Segment([hull(-oo),0],[1,0]) & Segment([0,1],[0,-1])) == IntervalVector.zero(2))
+    self.assertTrue((Segment([0,0],[1,2]) & Segment([0.5,0],[0.5,2])) == IntervalVector([0.5,1]))
+    self.assertTrue((Segment([-1,-1],[0,0]) & Segment([9,3],[0,0])) == IntervalVector([0,0]))
+    self.assertTrue((Segment([0,0],[10,0]) & Segment([2,0],[8,0])) == IntervalVector([[2,8],[0]])) # colinear case
+    self.assertTrue((Segment([0,0],[10,10]) & Segment([2,2],[8,8])) == IntervalVector([[2,8],[2,8]])) # colinear case
+    self.assertTrue((Segment([0,0],[10,0]) & Segment([2,1],[8,1])) == IntervalVector.empty(2)) # parallel case
+
+    self.assertTrue((Segment([2,0],[6,4]) & Segment([6,5],[5,6])) == IntervalVector.empty(2))
+    self.assertTrue(proj_intersection(Segment([2,0],[6,4]), Segment([6,5],[5,6])) == IntervalVector([6.5,4.5]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SepCartProd.py

@@ -0,0 +1,34 @@
+#!/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 TestSepCartProd(unittest.TestCase):
+  
+  def tests_SepCartProd(self):
+    
+    v = VectorVar(1)
+    s1 = SepInverse(AnalyticFunction([v], v), IntervalVector([[-1,1]]))
+    s2 = SepInverse(AnalyticFunction([v], v), IntervalVector([[5,6]]))
+
+    x = IntervalVector([[0,8],[5.5,oo]])
+    s3 = SepCartProd(s1,s2)
+    inner,outer = s3.separate(x)
+    self.assertTrue(inner == IntervalVector([[1,8],[6,oo]]))
+    self.assertTrue(outer == IntervalVector([[0,1],[5.5,6]]))
+
+    x = IntervalVector([[0,8],[5.5,oo]])
+    s4 = cart_prod(s1,s2)
+    inner,outer = s4.separate(x)
+    self.assertTrue(inner == IntervalVector([[1,8],[6,oo]]))
+    self.assertTrue(outer == IntervalVector([[0,1],[5.5,6]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SepCtcBoundary.py

@@ -0,0 +1,52 @@
+#!/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 TestSepCtcBoundary(unittest.TestCase):
+
+  def tests_SepCtcBoundary(self):
+
+    ctc_bound_diamond = CtcSegment([[-1],[0]], [[0],[-1]]) | CtcSegment([[0],[-1]], [[1],[0]]) \
+      | CtcSegment([[1],[0]], [[0],[1]]) | CtcSegment([[0],[1]], [[-1],[0]])
+
+    sep_diamond = SepCtcBoundary(ctc_bound_diamond,test_inside_diamond)
+    #draw_while_paving(IntervalVector([[-2,2],[-2,2]]), sep_diamond, 0.1)
+
+    x = IntervalVector(2)
+    inner,outer = sep_diamond.separate(IntervalVector(2))
+    self.assertTrue(inner == IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+
+    x = IntervalVector([[0,10],[0,10]])
+    inner,outer = sep_diamond.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer == IntervalVector([[0,1],[0,1]]))
+
+    x = IntervalVector([[0.2,10],[0.2,10]])
+    inner,outer = sep_diamond.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer == IntervalVector([[0.2,0.8],[0.2,0.8]]))
+
+    x = IntervalVector([[0.5,10],[0.5,10]])
+    inner,outer = sep_diamond.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer == IntervalVector([[0.5],[0.5]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SepInverse.py

@@ -0,0 +1,104 @@
+#!/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 TestSepInverse(unittest.TestCase):
+
+  def tests_SepInverse_box(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], [
+      x[0],
+      sqr(x[0]/7.)+sqr(x[1]/3.)
+    ])
+    s = SepInverse(f, [[0,oo],[-oo,1]])
+
+    b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+    inner,outer = s.separate(b)
+    self.assertTrue(inner == IntervalVector([[0],[-2.28,-1.56]]))
+    self.assertTrue(outer == b)
+
+    b = IntervalVector([[4,5.4],[-0.05,2.45]])
+    inner,outer = s.separate(b)
+    self.assertTrue(Approx(inner,1e-2) == IntervalVector([[4.039,5.40],[1.908,2.45]]))
+    self.assertTrue(outer == b)
+
+    b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+    inner,outer = s.separate(b)
+    self.assertTrue(Approx(inner,1e-2) == IntervalVector([[6.25,6.70],[0.9, 1.85]]))
+    self.assertTrue(Approx(inner,1e-2) == IntervalVector([[6.25,6.70],[0.9, 1.85]]))
+
+    b = IntervalVector([[-6,-5],[0,2]])
+    inner,outer = s.separate(b)
+    self.assertTrue(inner == b)
+    self.assertTrue(outer == IntervalVector.empty(2))
+
+    b = IntervalVector([[2,3],[-1,1]])
+    inner,outer = s.separate(b)
+    self.assertTrue(inner == IntervalVector.empty(2))
+    self.assertTrue(outer == b)
+
+  def tests_SepInverse_sep(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], [
+      x[0],
+      sqr(x[0]/7.)+sqr(x[1]/3.)
+    ])
+    s = SepInverse(f, SepWrapper_IntervalVector([[0,oo],[-oo,1]]))
+
+    b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+    inner,outer = s.separate(b)
+    self.assertTrue(inner == IntervalVector([[0],[-2.28,-1.56]]))
+    self.assertTrue(outer == b)
+
+    b = IntervalVector([[4,5.4],[-0.05,2.45]])
+    inner,outer = s.separate(b)
+    self.assertTrue(Approx(inner,1e-2) == IntervalVector([[4.039,5.40],[1.908,2.45]]))
+    self.assertTrue(outer == b)
+
+    b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+    inner,outer = s.separate(b)
+    self.assertTrue(Approx(inner,1e-2) == IntervalVector([[6.25,6.70],[0.9, 1.85]]))
+    self.assertTrue(Approx(inner,1e-2) == IntervalVector([[6.25,6.70],[0.9, 1.85]]))
+
+    b = IntervalVector([[-6,-5],[0,2]])
+    inner,outer = s.separate(b)
+    self.assertTrue(inner == b)
+    self.assertTrue(outer == IntervalVector.empty(2))
+
+    b = IntervalVector([[2,3],[-1,1]])
+    inner,outer = s.separate(b)
+    self.assertTrue(inner == IntervalVector.empty(2))
+    self.assertTrue(outer == b)
+
+  def tests_SepInverse_other_test(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(sqr(x[0])+sqr(x[1])))
+    s = SepInverse(f, [[0,1]])
+
+    #pave([[-5,5],[-5,5]], s, 0.01);
+
+    inner,outer = s.separate(IntervalVector([[0.1,0.2],[0.1,0.2]])) # fully inside
+    self.assertTrue(inner.is_empty())
+    self.assertTrue(outer == IntervalVector([[0.1,0.2],[0.1,0.2]]))
+
+    inner,outer = s.separate(IntervalVector([[-0.2,0.2],[-0.2,0.2]])) # fully inside
+    self.assertTrue(inner.is_empty())
+    self.assertTrue(outer == IntervalVector([[-0.2,0.2],[-0.2,0.2]]))
+
+    inner,outer = s.separate(IntervalVector(2))
+    self.assertTrue(inner == IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SepPolygon.py

@@ -0,0 +1,102 @@
+#!/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 TestSepPolygon(unittest.TestCase):
+
+  def tests_SepPolygon(self):
+
+    # Polygon, defined as a list of vertices
+    p = Polygon([[3,-1],[3,4],[5,6],[-1,1]])
+    s = SepPolygon(p)
+    c = CtcPolygon(p)
+
+    x = IntervalVector(2)
+    inner,outer = s.separate(IntervalVector(2))
+    self.assertTrue(inner == IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,5],[-1,6]]))
+
+    y = IntervalVector(2)
+    c.contract(y)
+    self.assertTrue(y == IntervalVector([[-1,5],[-1,6]]))
+
+    x = IntervalVector([[3.02,3.16],[2.5,3.2]]) # possible bug
+    inner,outer = s.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer.is_empty())
+
+  def tests_SepPolygon_fromCodac1(self):
+
+    # Polygone with hole, defined as a list of edges
+
+    s = SepPolygon([
+      # external border
+      [[6,-6], [7,9]],
+      [[7,9], [0,5]],
+      [[0,5], [-9,8]],
+      [[-9,8], [-8,-9]],
+      [[-8,-9], [6,-6]],
+      # hole
+      [[-2,3], [3.5,2]],
+      [[3.5,2], [1.5,0.5]],
+      [[1.5,0.5], [3,-4]],
+      [[3,-4], [-3,-3]],
+      [[-3,-3], [-2,3]]
+    ])
+
+    #draw_while_paving(IntervalVector([[-10,10],[-10,10]]), s, 0.1)
+
+    # Check a box inside the hole
+
+    x = IntervalVector([[0],[0]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    inner,outer = s.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer.is_empty())
+
+    # Check a box inside the polygon
+
+    x = IntervalVector([[5],[-5]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    inner,outer = s.separate(x)
+    self.assertTrue(inner.is_empty())
+    self.assertTrue(outer == x)
+
+    # Check a box outside the polygon
+
+    x = IntervalVector([[-1],[8]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    inner,outer = s.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer.is_empty())
+
+
+    # Other polygon, defined as a list of vertices
+
+    s = SepPolygon([[6,-6],[7,9],[0,5],[-9,8],[-8,-9]])
+
+    # Check a box inside the polygon
+
+    x = IntervalVector([[5],[-5]]).inflate(0.5)
+    inner,outer = s.separate(x)
+    self.assertTrue(inner.is_empty())
+    self.assertTrue(outer == x)
+
+    # Check a box outside the polygon
+
+    x = IntervalVector([[-1],[8]]).inflate(0.5)
+    inner,outer = s.separate(x)
+    self.assertTrue(inner == x)
+    self.assertTrue(outer.is_empty())
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SepProj.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 TestSepProj(unittest.TestCase):
+
+  def tests_SepProj(self):
+
+    x = VectorVar(3)
+    f_ellipsoid = AnalyticFunction([x], 2*sqr(x[0])+x[0]*x[1]+x[0]*x[2]+sqr(x[1])+sqr(x[2]))
+    sep_ellipsoid = SepInverse(f_ellipsoid, [0.7,1])
+    sep_proj = SepProj(sep_ellipsoid, [0,1], [[0.1,0.2]])
+
+    # todo: test with SepProj sep_proj(sep_ellipsoid, {0,1}, [[-oo,oo]])
+
+    #pave(IntervalVector([[-2,2],[-2,2]]), sep_proj, 0.1)
+
+    b = IntervalVector([[0.2,0.4],[0.0,1]])
+    inner,outer = sep_proj.separate(b,1e-3)
+    self.assertTrue(Approx(outer,1e-2) == IntervalVector([[0.2,0.4],[0,0.94]]))
+
+    b = IntervalVector([[-0.4,-0.2],[0.95,1.5]])
+    inner,outer = sep_proj.separate(b,1e-3)
+    self.assertTrue(Approx(outer,1e-2) == IntervalVector([[-0.4,-0.2],[0.95,1.15]]))
+
+    b = IntervalVector([[0.65],[-0.5,-0.4]])
+    inner,outer = sep_proj.separate(b,1e-3)
+    self.assertTrue(inner.is_empty())
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SepTransform.py

@@ -0,0 +1,41 @@
+#!/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 TestSepTransform(unittest.TestCase):
+  
+  def tests_SepTransform(self):
+    
+    x = VectorVar(2)
+    s1 = SepInverse(AnalyticFunction([x], sqr(x[0])+sqr(x[1])), [0,1])
+    s2 = SepTransform(s1,
+      AnalyticFunction([x], vec(x[0]+2,x[1]+2)),
+      AnalyticFunction([x], vec(x[0]-2,x[1]-2)))
+
+    #pave([[-5,5],[-5,5]], s2, 0.01)
+
+    inner,outer = s2.separate(IntervalVector(2))
+    self.assertTrue(inner == IntervalVector(2))
+    self.assertTrue(Approx(outer,1e-1) == IntervalVector([[-3,-1],[-3,-1]]))
+
+    inner,outer = s2.separate(IntervalVector([[-2.2,-1.8],[-2.2,-1.8]]))
+    self.assertTrue(inner.is_empty())
+    self.assertTrue(outer == IntervalVector([[-2.2,-1.8],[-2.2,-1.8]]))
+
+    b = IntervalVector([[-2.5,-1.5],[-2,10]])
+    #DefaultFigure.draw_box(b,Color.purple())
+    inner,outer = s2.separate(b)
+    #DefaultFigure.draw_box(xs.inner,Color.green())
+    self.assertTrue(Approx(inner,1e-1) == IntervalVector([[-2.5,-1.5],[-1.134,10]]))
+    self.assertTrue(Approx(outer,1e-1) == IntervalVector([[-2.5,-1.5],[-2,-1]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Vector.py

@@ -0,0 +1,41 @@
+#!/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 TestVector(unittest.TestCase):
+
+  def tests_Vector(self):
+    
+    self.assertTrue(Vector([1,2])+Vector([3,4]) == Vector([4,6]))
+    
+
+  def tests_vector_specific_to_python(self):
+
+    x = Vector([1,2,3])
+    y = Vector.zero(3)
+
+    i = 0
+    for xi in x: # using __iter__
+      y[i] = xi
+      i = i+1
+
+    self.assertTrue(x == y)
+
+    a,b,c = x # using __iter__
+    self.assertTrue(a == x[0])
+    self.assertTrue(b == x[1])
+    self.assertTrue(c == x[2])
+
+    v = Vector([*x, 42]) # using __iter__
+    self.assertTrue(v == [1,2,3,42])
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_arithmetic_add.py

@@ -0,0 +1,54 @@
+#!/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 TestArithmeticAdd(unittest.TestCase):
+
+  def tests_ArithmeticAdd(self):
+
+    # inline Vector operator+(const Vector& x1, const Vector& x2)
+    self.assertTrue(Vector([1,2,3])+Vector([5,6,7]) == Vector([6,8,10]))
+
+    # inline IntervalVector operator+(const Vector& x1, const IntervalVector& x2)
+    self.assertTrue(Vector([1,2,3])+IntervalVector([[-1,1],[-2,2],[-3,3]]) == IntervalVector([[0,2],[0,4],[0,6]]))
+
+    # Matrix operator+(const M& x1, const M_& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])+Matrix([[3,4],[5,6]]) == Matrix([[4,6],[8,10]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)+Matrix([[3,4],[5,6]]) == Matrix([[4,6],[8,10]]))
+    self.assertTrue(Matrix([[1,2],[3,4]])+Matrix([[3,4],[5,6]]).block(0,0,2,2) == Matrix([[4,6],[8,10]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)+Matrix([[3,4],[5,6]]).block(0,0,2,2) == Matrix([[4,6],[8,10]]))
+
+    # IntervalMatrix operator+(const M& x1, const IM& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])+IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)+IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]])+IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)+IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+
+    # inline IntervalVector operator+(const IntervalVector& x1, const Vector& x2)
+    self.assertTrue(IntervalVector([[-1,1],[-2,2],[-3,3]])+Vector([1,2,3]) == IntervalVector([[0,2],[0,4],[0,6]]))
+
+    # inline IntervalVector operator+(const IntervalVector& x1, const IntervalVector& x2)
+    self.assertTrue(IntervalVector([[-1,1],[-2,2],[-3,3]])+IntervalVector([[1],[2],[3]]) == IntervalVector([[0,2],[0,4],[0,6]]))
+
+    # IntervalMatrix operator+(const IM& x1, const M& x2)
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])+Matrix([[1,2],[3,4]]) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)+Matrix([[1,2],[3,4]]) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])+Matrix([[1,2],[3,4]]).block(0,0,2,2) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)+Matrix([[1,2],[3,4]]).block(0,0,2,2) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+
+    # IntervalMatrix operator+(const IM& x1, const IM_& x2)
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])+IntervalMatrix([[[1],[2]],[[3],[4]]]) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)+IntervalMatrix([[[1],[2]],[[3],[4]]]) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])+IntervalMatrix([[[1],[2]],[[3],[4]]]).block(0,0,2,2) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)+IntervalMatrix([[[1],[2]],[[3],[4]]]).block(0,0,2,2) == IntervalMatrix([[[0,2],[0,4]],[[0,6],[0,8]]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_arithmetic_div.py

@@ -0,0 +1,46 @@
+#!/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 TestArithmeticDiv(unittest.TestCase):
+
+  def tests_ArithmeticDiv(self):
+
+    #inline Vector operator/(const Vector& x1, double x2)
+    self.assertTrue(Approx(Vector([1,2,3])/10.) == Vector([.1,.2,.3]))
+
+    #inline IntervalVector operator/(const Vector& x1, const Interval& x2)
+    self.assertTrue(Approx(Vector([1,2,3])/Interval(10.,oo)) == IntervalVector([[0,.1],[0,.2],[0,.3]]))
+
+    #Matrix operator/(const M& x1, double x2)
+    self.assertTrue(Approx(Matrix([[1,2],[3,4]])/10.) == Matrix([[.1,.2],[.3,.4]]))
+    self.assertTrue(Approx(Matrix([[1,2],[3,4]]).block(0,0,2,2)/10.) == Matrix([[.1,.2],[.3,.4]]))
+
+    #IntervalMatrix operator/(const M& x1, const Interval& x2)
+    self.assertTrue(Approx(Matrix([[1,2],[3,4]])/Interval(10.,oo)) == IntervalMatrix([[[0,.1],[0,.2]],[[0,.3],[0,.4]]]))
+    self.assertTrue(Approx(Matrix([[1,2],[3,4]]).block(0,0,2,2)/Interval(10.,oo)) == IntervalMatrix([[[0,.1],[0,.2]],[[0,.3],[0,.4]]]))
+
+    #inline IntervalVector operator/(const IntervalVector& x1, double x2)
+    self.assertTrue(Approx(IntervalVector([[1],[2],[3]])/10.) == IntervalVector([[.1],[.2],[.3]]))
+
+    #inline IntervalVector operator/(const IntervalVector& x1, const Interval& x2)
+    self.assertTrue(Approx(IntervalVector([[1],[2],[3]])/Interval(10.,oo)) == IntervalVector([[0,.1],[0,.2],[0,.3]]))
+
+    #IntervalMatrix operator/(const IM& x1, double x2)
+    self.assertTrue(Approx(IntervalMatrix([[[1],[2]],[[3],[4]]])/10.) == IntervalMatrix([[[.1],[.2]],[[.3],[.4]]]))
+    self.assertTrue(Approx(IntervalMatrix([[[1],[2]],[[3],[4]]]).block(0,0,2,2)/10.) == IntervalMatrix([[[.1],[.2]],[[.3],[.4]]]))
+
+    #IntervalMatrix operator/(const IM& x1, const Interval& x2)
+    self.assertTrue(Approx(IntervalMatrix([[[1],[2]],[[3],[4]]])/Interval(10.,oo)) == IntervalMatrix([[[0,.1],[0,.2]],[[0,.3],[0,.4]]]))
+    self.assertTrue(Approx(IntervalMatrix([[[1],[2]],[[3],[4]]]).block(0,0,2,2)/Interval(10.,oo)) == IntervalMatrix([[[0,.1],[0,.2]],[[0,.3],[0,.4]]]))
+
+if __name__ ==  '__main__':
+  unittest.main()