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

codac4matlab/tests/test_arithmetic_mul.py

@@ -0,0 +1,114 @@
+#!/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 TestArithmeticMul(unittest.TestCase):
+
+  def test_ArithmeticMul(self):
+
+    # inline Vector operator*(double x1, const Vector& x2)
+    self.assertTrue(2.*Vector([1,2]) == Vector([2,4]))
+
+    # Matrix operator*(double x1, const M& x2)
+    self.assertTrue(2.*Matrix([[1,2],[3,4]]) == Matrix([[2,4],[6,8]]))
+    self.assertTrue(2.*Matrix([[1,2],[3,4]]).block(0,0,2,2) == Matrix([[2,4],[6,8]]))
+
+    # inline IntervalVector operator*(double x1, const IntervalVector& x2)
+    self.assertTrue(2.*IntervalVector([[-1,1],[-2,2]]) == IntervalVector([[-2,2],[-4,4]]))
+
+    # IntervalMatrix operator*(double x1, const IM& x2)
+    self.assertTrue(2.*IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]) == IntervalMatrix([[[-2,2],[-4,4]],[[-6,6],[-8,8]]]))
+    self.assertTrue(2.*IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2) == IntervalMatrix([[[-2,2],[-4,4]],[[-6,6],[-8,8]]]))
+
+    # inline IntervalVector operator*(const Interval& x1, const Vector& x2)
+    self.assertTrue(Interval(-1,1)*Vector([1,2]) == IntervalVector([[-1,1],[-2,2]]))
+
+    # IntervalMatrix operator*(const Interval& x1, const M& x2)
+    self.assertTrue(Interval(-1,1)*Matrix([[1,2],[3,4]]) == IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]))
+    self.assertTrue(Interval(-1,1)*Matrix([[1,2],[3,4]]).block(0,0,2,2) == IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]))
+
+    # inline IntervalVector operator*(const Interval& x1, const IntervalVector& x2)
+    self.assertTrue(Interval(2,oo)*IntervalVector([[1,2],[4,8]]) == IntervalVector([[2,oo],[8,oo]]))
+
+    # IntervalMatrix operator*(const Interval& x1, const IM& x2)
+    self.assertTrue(Interval(-1,1)*IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]) == IntervalMatrix([[[-2,2],[-3,3]],[[-4,4],[-5,5]]]))
+    self.assertTrue(Interval(-1,1)*IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]).block(0,0,2,2) == IntervalMatrix([[[-2,2],[-3,3]],[[-4,4],[-5,5]]]))
+
+    # inline Vector operator*(const Vector& x1, double x2)
+    self.assertTrue(Vector([1,2])*2. == Vector([2,4]))
+
+    # inline IntervalVector operator*(const Vector& x1, const Interval& x2)
+    self.assertTrue(Vector([1,2])*Interval(-1,1) == IntervalVector([[-1,1],[-2,2]]))
+
+    # Matrix operator*(const M& x1, double x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])*2. == Matrix([[2,4],[6,8]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*2. == Matrix([[2,4],[6,8]]))
+
+    # IntervalMatrix operator*(const M& x1, const Interval& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])*Interval(-1,1) == IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*Interval(-1,1) == IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]))
+
+    # Vector operator*(const M& x1, const Vector& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])*Vector([5,6]) == Vector([17,39]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*Vector([5,6]) == Vector([17,39]))
+
+    # Matrix operator*(const M& x1, const M_& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])*Matrix([[5,6],[7,8]]) == Matrix([[19,22],[43,50]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*Matrix([[5,6],[7,8]]) == Matrix([[19,22],[43,50]]))
+    self.assertTrue(Matrix([[1,2],[3,4]])*Matrix([[5,6],[7,8]]).block(0,0,2,2) == Matrix([[19,22],[43,50]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*Matrix([[5,6],[7,8]]).block(0,0,2,2) == Matrix([[19,22],[43,50]]))
+
+    # IntervalVector operator*(const M& x1, const IntervalVector& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])*IntervalVector([5,6]) == IntervalVector([17,39]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*IntervalVector([5,6]) == IntervalVector([17,39]))
+
+    # IntervalMatrix operator*(const M& x1, const IM& x2)
+    self.assertTrue(Matrix([[1,2],[3,4]])*IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]) == IntervalMatrix([[[19,22],[22,25]],[[43,50],[50,57]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]) == IntervalMatrix([[[19,22],[22,25]],[[43,50],[50,57]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]])*IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]).block(0,0,2,2) == IntervalMatrix([[[19,22],[22,25]],[[43,50],[50,57]]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)*IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]).block(0,0,2,2) == IntervalMatrix([[[19,22],[22,25]],[[43,50],[50,57]]]))
+
+    # inline IntervalVector operator*(const IntervalVector& x1, double x2)
+    self.assertTrue(IntervalVector([[-1,1],[-2,2]])*2. == IntervalVector([[-2,2],[-4,4]]))
+
+    # inline IntervalVector operator*(const IntervalVector& x1, const Interval& x2)
+    self.assertTrue(IntervalVector([[1,2],[4,8]])*Interval(2,oo) == IntervalVector([[2,oo],[8,oo]]))
+
+    # IntervalMatrix operator*(const IM& x1, double x2)
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])*2. == IntervalMatrix([[[-2,2],[-4,4]],[[-6,6],[-8,8]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)*2. == IntervalMatrix([[[-2,2],[-4,4]],[[-6,6],[-8,8]]]))
+
+    # IntervalMatrix operator*(const IM& x1, const Interval& x2)
+    self.assertTrue(IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]])*Interval(-1,1) == IntervalMatrix([[[-2,2],[-3,3]],[[-4,4],[-5,5]]]))
+    self.assertTrue(IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]).block(0,0,2,2)*Interval(-1,1) == IntervalMatrix([[[-2,2],[-3,3]],[[-4,4],[-5,5]]]))
+
+    # IntervalVector operator*(const IM& x1, const Vector& x2)
+    self.assertTrue(IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]])*Vector([5,6]) == IntervalVector([[17,28],[39,50]]))
+    self.assertTrue(IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]).block(0,0,2,2)*Vector([5,6]) == IntervalVector([[17,28],[39,50]]))
+
+    # IntervalMatrix operator*(const IM& x1, const M& x2)
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]])*Matrix([[1,2],[3,4]]) == IntervalMatrix([[[23,27],[34,40]],[[31,35],[46,52]]]))
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]).block(0,0,2,2)*Matrix([[1,2],[3,4]]) == IntervalMatrix([[[23,27],[34,40]],[[31,35],[46,52]]]))
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]])*Matrix([[1,2],[3,4]]).block(0,0,2,2) == IntervalMatrix([[[23,27],[34,40]],[[31,35],[46,52]]]))
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]).block(0,0,2,2)*Matrix([[1,2],[3,4]]).block(0,0,2,2) == IntervalMatrix([[[23,27],[34,40]],[[31,35],[46,52]]]))
+
+    # IntervalVector operator*(const IM& x1, const IntervalVector& x2)
+    self.assertTrue(IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]])*IntervalVector([[5,6],[7,8]]) == IntervalVector([[19,36],[43,64]]))
+    self.assertTrue(IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]).block(0,0,2,2)*IntervalVector([[5,6],[7,8]]) == IntervalVector([[19,36],[43,64]]))
+
+    # IntervalMatrix operator*(const IM& x1, const IM_& x2)
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]])*IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]) == IntervalMatrix([[[23,40],[34,53]],[[31,52],[46,69]]]))
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]).block(0,0,2,2)*IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]) == IntervalMatrix([[[23,40],[34,53]],[[31,52],[46,69]]]))
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]])*IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]).block(0,0,2,2) == IntervalMatrix([[[23,40],[34,53]],[[31,52],[46,69]]]))
+    self.assertTrue(IntervalMatrix([[[5,6],[6,7]],[[7,8],[8,9]]]).block(0,0,2,2)*IntervalMatrix([[[1,2],[2,3]],[[3,4],[4,5]]]).block(0,0,2,2) == IntervalMatrix([[[23,40],[34,53]],[[31,52],[46,69]]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_arithmetic_sub.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 test_ArithmeticAdd(self):
+
+    # inline Vector operator-(const Vector& x1, const Vector& x2)
+    self.assertTrue(Vector([1,2,3])-Vector([5,6,7]) == Vector([-4,-4,-4]))
+
+    # 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([[-2,-2],[-2,-2]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)-Matrix([[3,4],[5,6]]) == Matrix([[-2,-2],[-2,-2]]))
+    self.assertTrue(Matrix([[1,2],[3,4]])-Matrix([[3,4],[5,6]]).block(0,0,2,2) == Matrix([[-2,-2],[-2,-2]]))
+    self.assertTrue(Matrix([[1,2],[3,4]]).block(0,0,2,2)-Matrix([[3,4],[5,6]]).block(0,0,2,2) == Matrix([[-2,-2],[-2,-2]]))
+
+    # 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([[-2,0],[-4,0],[-6,0]]))
+
+    # inline IntervalVector operator-(const IntervalVector& x1, const IntervalVector& x2)
+    self.assertTrue(IntervalVector([[-1,1],[-2,2],[-3,3]])-IntervalVector([[1],[2],[3]]) == IntervalVector([[-2,0],[-4,0],[-6,0]]))
+
+    # 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([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)-Matrix([[1,2],[3,4]]) == IntervalMatrix([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])-Matrix([[1,2],[3,4]]).block(0,0,2,2) == IntervalMatrix([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+    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([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+
+    # 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([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]]).block(0,0,2,2)-IntervalMatrix([[[1],[2]],[[3],[4]]]) == IntervalMatrix([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+    self.assertTrue(IntervalMatrix([[[-1,1],[-2,2]],[[-3,3],[-4,4]]])-IntervalMatrix([[[1],[2]],[[3],[4]]]).block(0,0,2,2) == IntervalMatrix([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+    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([[[-2,0],[-4,0]],[[-6,0],[-8,0]]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_capd.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Maël Godard
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestCAPD(unittest.TestCase):
+
+  def test_capd(self):
+     self.assertTrue(True)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_cart_prod.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Gilles Chabert, Simon Rohou
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+import sys
+import math
+
+class TestIntervalVector(unittest.TestCase):
+
+  def test_cart_prod_vector(self):
+
+    self.assertTrue(cart_prod(Vector([3])) == Vector([3]))
+    self.assertTrue(cart_prod(1,2,3.5) == Vector([1,2,3.5]))
+    self.assertTrue(cart_prod(1,2,3.5,Vector.ones(2)) == Vector([1,2,3.5,1,1]))
+    self.assertTrue(cart_prod(Vector.ones(2),1,2,3.5) == Vector([1,1,1,2,3.5]))
+    self.assertTrue(cart_prod(Vector.zero(3)) == Vector.zero(3))
+    self.assertTrue(cart_prod(Vector.zero(3),Vector.ones(4)) == Vector([0,0,0,1,1,1,1]))
+
+  def test_cart_prod_intervalvector(self):
+
+    self.assertTrue(cart_prod(IntervalVector([[0,1]])) == IntervalVector([[0,1]]))
+    self.assertTrue(cart_prod(IntervalVector([[0,1],[2,3],[4,5]]),IntervalVector.empty(3)).is_empty())
+    self.assertTrue(cart_prod(IntervalVector.empty(3),IntervalVector([[0,1],[2,3],[4,5]])).is_empty())
+    self.assertTrue(cart_prod([[0,1],[2,3],[4,5]]) == IntervalVector([[0,1],[2,3],[4,5]]))
+    self.assertTrue(cart_prod(IntervalVector.empty(3)) == IntervalVector.empty(3))
+    self.assertTrue(cart_prod([[0,1],[2,3],[4,5]],[[8,9]]) == IntervalVector([[0,1],[2,3],[4,5],[8,9]]))
+    self.assertTrue(cart_prod(25.,[[0,1],[2,3],[4,5]],[[8,9]],Vector.ones(3)) == IntervalVector([[25],[0,1],[2,3],[4,5],[8,9],[1],[1],[1]]))
+    self.assertTrue(cart_prod([-oo,oo],[-oo,oo],42.) == IntervalVector([[-oo,oo],[-oo,oo],[42.,42.]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_eigen.py

@@ -0,0 +1,19 @@
+#!/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 TestEigen(unittest.TestCase):
+
+  def test_eigen(self):
+     self.assertTrue(True)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_geometry.py

@@ -0,0 +1,136 @@
+#!/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 TestGeometry(unittest.TestCase):
+
+  def test_orientation(self):
+    
+    # Align points
+    self.assertTrue(orientation([0.,0.],[5.,0.],[8.,0.]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0.,0.],[5.,0.],[-2.,0.]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0.,0.],[-2.,0.],[5.,0.]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0.,0.],[0.,0.],[5.,0.]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0.,0.],[0.,0.],[0.,0.]) == OrientationInterval.COLINEAR)
+
+    # Clockwise points
+    self.assertTrue(orientation([0.,0.],[0.,-5.],[-2.,-5.]) == OrientationInterval.COUNTERCLOCKWISE)
+    self.assertTrue(orientation([-999.,0.1],[0.,0.],[-999.,-0.1]) == OrientationInterval.COUNTERCLOCKWISE)
+
+    # Anticlockwise points
+    self.assertTrue(orientation([0.,0.],[0.,-5.],[2.,-5.]) == OrientationInterval.CLOCKWISE)
+    self.assertTrue(orientation([999.,0.1],[0.,0.],[999.,-0.1]) == OrientationInterval.CLOCKWISE)
+
+    # Other tests
+    self.assertTrue(orientation([0,0],[1,1],[0,2]) == OrientationInterval.CLOCKWISE)
+    self.assertTrue(orientation([0,0],[1,1],[2,2]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0,0],[1,1],[2.2,2]) == OrientationInterval.COUNTERCLOCKWISE)
+    self.assertTrue(orientation([0,0],[2,2],[2,2]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0,0],[2,2],[4,4]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0,0],[8,8],[4,4]) == OrientationInterval.COLINEAR)
+    self.assertTrue(orientation([0,0],[10,1],[4,4]) == OrientationInterval.CLOCKWISE)
+    self.assertTrue(orientation([0,0],[2,2],[10,1]) == OrientationInterval.COUNTERCLOCKWISE)
+
+  def test_alignments(self):
+    
+    # Alignments
+    p1 = IntervalVector([0.,0.])
+    p2 = IntervalVector([0.,1.])
+    p3 = IntervalVector([0.,10.])
+    p4 = IntervalVector([1.,10.])
+    p5 = IntervalVector([0.,9.+1e-8*Interval(-1.,1.)])
+    p6 = IntervalVector([0.+1e-8*Interval(-1.,1.),9.])
+    p7 = IntervalVector([0.+1e-8*Interval(-1.,1.),9.+1e-8*Interval(-1.,1.)])
+
+    self.assertTrue(aligned(p1,p2,p3) == BoolInterval.TRUE)
+    self.assertTrue(aligned(p1,p2,p4) == BoolInterval.FALSE)
+    self.assertTrue(aligned(p1,p1,p4) == BoolInterval.TRUE)
+    self.assertTrue(aligned(p1,p2,p5) == BoolInterval.TRUE)
+    self.assertTrue(aligned(p1,p2,p6) == BoolInterval.UNKNOWN)
+    self.assertTrue(aligned(p1,p2,p7) == BoolInterval.UNKNOWN)
+    self.assertTrue(aligned([0,0],[1,1],[10,10]) == BoolInterval.TRUE)
+    self.assertTrue(aligned([[-oo,0],[-oo,0]],[1,1],[10,10]) == BoolInterval.UNKNOWN)
+    self.assertTrue(aligned(IntervalVector(2),[1,1],[10,10]) == BoolInterval.UNKNOWN)
+
+  def test_convex_hull(self):
+
+    v = [
+      [0,3],[1,1],[2,2],[4,4],[0,0],[1,2],[3,1],[3,3]
+    ]
+
+    hull = convex_hull(v)
+
+    self.assertTrue(hull[0] == IntervalVector([0,0]))
+    self.assertTrue(hull[1] == IntervalVector([3,1]))
+    self.assertTrue(hull[2] == IntervalVector([4,4]))
+    self.assertTrue(hull[3] == IntervalVector([0,3]))
+    self.assertTrue(len(hull) == 4)
+
+    v = [
+      [1,3],[1,4],[1.5,2],[2,1],[2,2],[3,0],
+      [3,3],[3,4.5],[4,2.5],[4,4],[5,1],[5,2],
+      [4,0],[5,0],[5,5],[6,0],[7,2]
+    ]
+
+    hull = convex_hull(v)
+
+    self.assertTrue(hull[0] == IntervalVector([3,0]))
+    self.assertTrue(hull[1] == IntervalVector([6,0]))
+    self.assertTrue(hull[2] == IntervalVector([7,2]))
+    self.assertTrue(hull[3] == IntervalVector([5,5]))
+    self.assertTrue(hull[4] == IntervalVector([3,4.5]))
+    self.assertTrue(hull[5] == IntervalVector([1,4]))
+    self.assertTrue(hull[6] == IntervalVector([1,3]))
+    self.assertTrue(hull[7] == IntervalVector([1.5,2]))
+    self.assertTrue(hull[8] == IntervalVector([2,1]))
+    self.assertTrue(len(hull) == 9)
+
+    v = [
+      [0.307007,0.0340742],
+      [0.0340742,0.307],
+      [0.1,0.2],[0.1,0.2],[0.2,0.1],[0.1,0.1]
+    ]
+
+    hull = convex_hull(v)
+
+    self.assertTrue(hull[0] == IntervalVector([0.307007,0.0340742]))
+    self.assertTrue(hull[1] == IntervalVector([0.0340742,0.307]))
+    self.assertTrue(hull[2] == IntervalVector([0.1,0.1]))
+    self.assertTrue(len(hull) == 3)
+
+    # Other test
+
+    v = [
+      [-4041.935273669676917052129283547401428223,-5492.667604696881426207255572080612182617],
+      [-2103.177277725693329557543620467185974121,-5492.667604696881426207255572080612182617],
+      [5720.923292917194885376375168561935424805,-975.4210340695084369144751690328121185303],
+      [9206.843580880462468485347926616668701172,5062.370015818080901226494461297988891602],
+      [52.79381299725321952109879930503666400909,5062.370015818080901226494461297988891602],
+      [-4041.935273669676917052129283547401428223-1,-5592.667604696874150249641388654708862305],
+      [9206.843580880462468485347926616668701172,6551.674997467660432448610663414001464844],
+      [52.79381299725321952109879930503666400909,6551.674997467660432448610663414001464844],
+      [-4041.935273669676917052129283547401428223,-540.603823869623056452837772667407989502]
+    ]
+    v_save = v
+
+    hull = convex_hull(v)
+
+    self.assertTrue(hull[0] == v_save[5])
+    self.assertTrue(hull[1] == v_save[1])
+    self.assertTrue(hull[2] == v_save[2])
+    self.assertTrue(hull[3] == v_save[3])
+    self.assertTrue(hull[4] == v_save[6])
+    self.assertTrue(hull[5] == v_save[7])
+    self.assertTrue(hull[6] == v_save[8])
+    self.assertTrue(len(hull) == 7)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_hull.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Gilles Chabert, Simon Rohou
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+import sys
+import math
+
+class TestHull(unittest.TestCase):
+
+  def test_hull_IntervalVector(self):
+
+    self.assertTrue(hull(Vector([1,2])) == IntervalVector([[1,1],[2,2]]))
+    self.assertTrue(hull(Vector([1,2]),Vector([1,2]),Vector([1,2]),Vector([1,2])) == IntervalVector([[1,1],[2,2]]))
+    self.assertTrue(hull(Vector([1,2]),Vector([9,10])) == IntervalVector([[1,9],[2,10]]))
+    self.assertTrue(hull(Vector([1,2]),IntervalVector([9,10])) == IntervalVector([[1,9],[2,10]]))
+    self.assertTrue(hull(IntervalVector([1,2]),Vector([9,10])) == IntervalVector([[1,9],[2,10]]))
+    self.assertTrue(hull(IntervalVector([1,2]),IntervalVector([9,10])) == IntervalVector([[1,9],[2,10]]))
+    self.assertTrue(hull(IntervalVector([1,2]),IntervalVector.empty(2)) == IntervalVector([[1,1],[2,2]]))
+    self.assertTrue(hull(IntervalVector([1,2])) == IntervalVector([[1,1],[2,2]]))
+    self.assertTrue(hull(2.*IntervalVector([1,2])) == IntervalVector([[2,2],[4,4]]))
+
+  def test_hull_IntervalMatrix(self):
+
+    self.assertTrue(hull(Matrix([[1,2],[3,4]])) == IntervalMatrix(Matrix([[1,2],[3,4]])))
+    self.assertTrue(hull(3.*Matrix([[1,2],[3,4]])) == IntervalMatrix(Matrix([[3,6],[9,12]])))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_ibex.py

@@ -0,0 +1,19 @@
+#!/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 TestIbex(unittest.TestCase):
+
+  def test_ibex(self):
+     self.assertTrue(True) # IBEX is not available in Python
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_inversion.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Damien Massé
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+
+import unittest
+from codac import *
+
+class TestInversion(unittest.TestCase):
+
+  def test_Inversion_1(self):
+
+    x = Matrix([
+      [ 1, 2, 0 ],
+      [ 3, 4, 1 ],
+      [ 0, 1, 0 ],
+    ])
+
+    y = inverse_enclosure(x)
+    self.assertTrue((x*y).contains(Matrix.eye(3,3)))
+
+
+  def test_Inversion_2(self):
+
+    x = IntervalMatrix([
+      [ [0.0,0.0], [-0.1,-0.1], [0.2,0.2]  ],
+      [ [0.0,0.0], [-0.2,-0.2], [0.1,0.1] ],
+      [ [0.1,0.1], [-0.1,-0.1], [0.1,0.1] ]
+    ])
+
+    y = infinite_sum_enclosure(x)
+    #self.assertTrue(Approx(y.max_rad())==Interval(5.0)/Interval(2.0))
+
+    z = inverse_enclosure(x)
+    self.assertTrue(z(1,2)==Interval(0))
+    self.assertTrue(Approx(z*x)==IntervalMatrix.eye(3,3))
+
+
+  def test_Inversion_3(self):
+
+    u = Matrix([
+       [ 1,2,3 ],
+       [ 1,3,5 ],
+       [ 3,4,5 ]
+     ])
+
+    v = inverse_enclosure(u)
+    self.assertTrue((u*v).contains(Matrix.eye(3,3)))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_linear_ctc.py

@@ -0,0 +1,77 @@
+#!/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 TestLinearCtc(unittest.TestCase):
+  
+  def test_linear_ctc(self):
+      
+    A = IntervalMatrix([
+      [[4,5],[-1,1],[1.5,2.5]],
+      [[-0.5,0.5],[-7,-5],[1,2]],
+      [[-1.5,-0.5],[-0.7,-0.5],[2,3]]
+    ])
+    x = IntervalVector([[-oo,oo],[-oo,oo],[-oo,oo]])
+    b = IntervalVector([[3,4],[0,2],[3,4]])
+
+    # Numerical values come from the book:
+    #   Applied Interval Analysis
+    #   Luc Jaulin, Michel Kieffer, Olivier Didrit, Éric Walter
+    #   2001, Springer London
+    #   doi: https:#doi.org/10.1007/978-1-4471-0249-6
+
+    # CtcGaussElim
+
+    ctc_ge = CtcGaussElim()
+    ctc_ge.contract(A,x,b)
+    self.assertTrue(Approx(x) == IntervalVector([
+      [-1.819278874340436,1.168720384766974],
+      [-0.4140698379116945,1.725229626734416],
+      [0.7002320584443487,3.42075434825093]
+    ]))
+
+    # CtcGaussSeidel
+
+    ctc_gs = CtcGaussSeidel()
+    x = IntervalVector([[-10,10],[-10,10],[-10,10]])
+    for k in range(0,100):
+      ctc_gs.contract(A,x,b)
+    self.assertTrue(Approx(x) == IntervalVector([
+      [-2.084512144759555,1.63672286912456],
+      [-0.7369829550424718,1.74356809144887],
+      [-0.3213286433350618,3.837791484351055]
+    ]))
+
+    # CtcGaussSeidel with preconditioning
+
+    ctc_gsp = CtcLinearPrecond(ctc_gs)
+    x = IntervalVector([[-10,10],[-10,10],[-10,10]])
+    for k in range(0,100):
+      ctc_gsp.contract(A,x,b)
+    self.assertTrue(Approx(x) == IntervalVector([
+      [-1.106970597649814,1.383669626776028],
+      [-0.8113846871807701,1.332001097010008],
+      [0.5757415290046493,2.984085335831012]
+    ]))
+
+    # CtcGaussElim with preconditioning
+
+    ctc_gep = CtcLinearPrecond(ctc_ge)
+    x = IntervalVector([[-oo,oo],[-oo,oo],[-oo,oo]])
+    ctc_gep.contract(A,x,b)
+    self.assertTrue(Approx(x) == IntervalVector([
+      [-1.106970597649814,1.383669626776028],
+      [-0.7852408901116992,1.332001097010009],
+      [0.7583501672635362,2.984085335831012]
+    ]))
+
+if __name__ ==  '__main__':
+  unittest.main()