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

codac4matlab/tests/test_CtcInter.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 TestCtcInter(unittest.TestCase):
+  
+  def test_CtcInter(self):
+    
+    c1 = CtcWrapper([[-10,10],[-2,2]])
+    c2 = CtcWrapper([[-12,2],[0,4]])
+
+    c3 = c1 & c2
+
+    x = IntervalVector([[-oo,oo],[-oo,oo]])
+    c3.contract(x)
+    self.assertTrue(x == IntervalVector([[-10,2],[0,2]]))
+
+    x = IntervalVector([[-oo,0],[-oo,0]])
+    c3.contract(x)
+    self.assertTrue(x == IntervalVector([[-10,0],[0,0]]))
+
+    x = IntervalVector([[0,oo],[0,oo]])
+    c3.contract(x)
+    self.assertTrue(x == IntervalVector([[0,2],[0,2]]))
+
+    x = IntervalVector([[0,0],[0,0]])
+    c3.contract(x)
+    self.assertTrue(x == IntervalVector.zero(2))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcInverse.py

@@ -0,0 +1,213 @@
+#!/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 TestCtcInverse(unittest.TestCase):
+
+  # not supported (yet) in Python # Contractors based on functions with two variables
+  # not supported (yet) in Python x = ScalarVar()
+  # not supported (yet) in Python y = ScalarVar()
+  # not supported (yet) in Python f = AnalyticFunction([x,y], x-y)
+  # not supported (yet) in Python c = CtcInverse(f, Interval(0.))
+
+  def test_CtcInverse_1(self):
+
+    x = VectorVar(1)
+    f = AnalyticFunction([x], x[0]-42)
+    c = CtcInverse(f, Interval(0.))
+    a = IntervalVector(1)
+    c.contract(a)
+    self.assertTrue(a == IntervalVector([[42]]))
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], x[0]-x[1])
+    c = CtcInverse(f, 0)
+    self.assertTrue(c.fnc().input_size() == 2)
+
+    b = IntervalVector(2)
+
+    c.contract(b)
+    self.assertTrue(b == IntervalVector(2))
+
+    b = IntervalVector([[1,2],[1,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,2],[1,2]]))
+
+    b = IntervalVector([[1,oo],[1,oo]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,oo],[1,oo]]))
+
+    b = IntervalVector([[10],[10]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[10],[10]]))
+
+    b = IntervalVector([[1,5],[8,9]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+
+  def test_CtcInverse_2(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0]-x[1]))
+    c = CtcInverse(f, [[0]])
+
+    b = IntervalVector(2)
+
+    c.contract(b)
+    self.assertTrue(b == IntervalVector(2))
+
+    b = IntervalVector([[1,2],[1,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,2],[1,2]]))
+
+    b = IntervalVector([[1,oo],[1,oo]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,oo],[1,oo]]))
+
+    b = IntervalVector([[10],[10]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[10],[10]]))
+
+    b = IntervalVector([[1,5],[8,9]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+  
+  def test_CtcInverse_3(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0],sqr(x[0]/7.)+sqr(x[1]/3.)))
+    c = CtcInverse(f, [[0,oo],[1]])
+
+    b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+
+    b = IntervalVector([[4,5.4],[-0.05,2.45]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[4.0397,5.40],[1.9089,2.45]]))
+
+    b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[6.25,6.67],[0.9,1.351]]))
+
+    b = IntervalVector([[-6,-5],[0,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+
+    b = IntervalVector([[2,3],[-1,1]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+  
+  def test_CtcInverse_4(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0],sqr(x[0]/7.)+sqr(x[1]/3.)))
+    c = CtcInverse(f, CtcWrapper([[0,oo],[1]]))
+
+    b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+
+    b = IntervalVector([[4,5.4],[-0.05,2.45]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[4.0397,5.40],[1.9089,2.45]]))
+
+    b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[6.25,6.67],[0.9,1.351]]))
+
+    b = IntervalVector([[-6,-5],[0,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+
+    b = IntervalVector([[2,3],[-1,1]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector.empty(2))
+  
+  def test_ParabolasExample(self):
+
+    u = ScalarVar()
+    v = ScalarVar()
+    a = VectorVar(4)
+    a0 = VectorVar(3); a1 = VectorVar(3); a2 = VectorVar(3)
+    b0 = VectorVar(3); b1 = VectorVar(3); b2 = VectorVar(3)
+
+    b = AnalyticFunction([u,a0,a1,a2], sqr(1-u)*a0+2*u*(1-u)*a1+sqr(u)*a2)
+    f = AnalyticFunction([u,v,a0,a1,a2,b0,b1,b2], (1-v)*b(u,a0,a1,a2)+v*b(u,b0,b1,b2))
+
+    h = AnalyticFunction([a],
+       f(a[0],a[1],
+         IntervalVector([[0],[0],[0]]),IntervalVector([[1],[0],[1]]),IntervalVector([[2],[0],[0]]),
+         IntervalVector([[0],[2],[0]]),IntervalVector([[1],[2],[1]]),IntervalVector([[2],[2],[0]]))
+      -f(a[2],a[3],
+         IntervalVector([[0],[0],[0.55]]),IntervalVector([[0],[1],[-0.45]]),IntervalVector([[0],[2],[0.55]]),
+         IntervalVector([[2],[0],[0.55]]),IntervalVector([[2],[1],[-0.45]]),IntervalVector([[2],[2],[0.55]]))
+    )
+
+    ctc = CtcInverse(h, [0,0,0])
+    x0 = [[0,1],[0,1],[0.05,0.18],[0.05,0.18]]
+    #DefaultFigure.pave(x0, ctc, 0.001)
+    p = pave(x0, ctc, 0.01)
+    cs = p.connected_subsets()
+    self.assertTrue(len(cs) == 1)
+    hull = IntervalVector([[0.149199,0.182388],[0.148306,0.1826],[0.148054,0.18],[0.148732,0.18]])
+    hull.inflate(1e-4)
+    self.assertTrue(hull.is_superset(cs[0].box()))
+  
+  def test_automatic_deduction_issue245(self):
+
+    s = VectorVar(2)
+    f = AnalyticFunction([s],[sqr(s[0])+sqr(s[1])-1.0])
+
+    # Compilation checks:
+
+    s1 = SepInverse(f,IntervalVector([0.0])*0.)
+    s2 = SepInverse(f,IntervalVector([0.0]))
+    s3 = SepInverse(f,Vector([0.0]))
+    s4 = SepInverse(f,[[0.0,0.0]])
+    s5 = SepInverse(f,[0.0])
+    s6 = SepInverse(f,[0])
+
+    c1 = CtcInverse(f,IntervalVector([0.0])*0.)
+    c2 = CtcInverse(f,IntervalVector([0.0]))
+    c3 = CtcInverse(f,Vector([0.0]))
+    c4 = CtcInverse(f,[[0.0,0.0]])
+    c5 = CtcInverse(f,[0.0])
+    c6 = CtcInverse(f,[0])
+
+    inner,outer = s1.separate(IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+    inner,outer = s2.separate(IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+    inner,outer = s3.separate(IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+    inner,outer = s4.separate(IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+    inner,outer = s5.separate(IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+    inner,outer = s6.separate(IntervalVector(2))
+    self.assertTrue(outer == IntervalVector([[-1,1],[-1,1]]))
+
+    x = IntervalVector(2); c1.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+    x = IntervalVector(2); c2.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+    x = IntervalVector(2); c3.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+    x = IntervalVector(2); c4.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+    x = IntervalVector(2); c5.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+    x = IntervalVector(2); c6.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcInverseNotIn.py

@@ -0,0 +1,129 @@
+#!/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 TestCtcInverseNotIn(unittest.TestCase):
+
+  # Multivariable functions not supported (yet) for CtcInverseNotInNotIn: ScalarVar x,y
+  # Multivariable functions not supported (yet) for CtcInverseNotInNotIn: AnalyticFunction f { {x,y}, x-y }
+  # Multivariable functions not supported (yet) for CtcInverseNotInNotIn: CtcInverseNotInNotIn<Interval> c(f, Interval(0.))
+
+  def test_CtcInverseNotIn_2(self):
+
+    # Test not really relevant, but copied from CtcInverse:
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0]-x[1]))
+    c = CtcInverseNotIn(f, [[0]])
+
+    #pave(IntervalVector([[-10,10],[-10,10]]), c, 0.1)
+
+    b = IntervalVector(2)
+
+    c.contract(b)
+    self.assertTrue(b == IntervalVector(2))
+
+    b = IntervalVector([[1,2],[1,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,2],[1,2]]))
+
+    b = IntervalVector([[1,oo],[1,oo]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,oo],[1,oo]]))
+
+    b = IntervalVector([[10],[10]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[10],[10]]))
+
+    b = IntervalVector([[1,5],[8,9]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[1,5],[8,9]]))
+  
+  def test_CtcInverseNotIn_3(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0],sqr(x[0]/7.)+sqr(x[1]/3.)))
+    c = CtcInverseNotIn(f, [[0,oo],[1]])
+
+    b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[0,0.8],[-2.28,-1.56]]))
+
+    b = IntervalVector([[4,5.4],[-0.05,2.45]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[4,5.4],[-0.05,2.45]]))
+
+    b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[6.25,6.70],[0.9,1.85]]))
+
+    b = IntervalVector([[-6,-5],[0,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[-6,-5],[0,2]]))
+
+    b = IntervalVector([[2,3],[-1,1]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[2,3],[-1,1]]))
+  
+  # disabled: def tests_CtcInverseNotIn_3_CtcWrapper(self):
+  # disabled:   
+  # disabled:   x = VectorVar(2)
+  # disabled:   f = AnalyticFunction([x], vec(x[0],sqr(x[0]/7.)+sqr(x[1]/3.)))
+  # disabled:   c = CtcInverseNotIn(f, CtcWrapper([[0,oo],[1]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(b == IntervalVector([[0,0.8],[-2.28,-1.56]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[4,5.4],[-0.05,2.45]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(Approx(b,1e-2) == IntervalVector([[4,5.4],[-0.05,2.45]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(Approx(b,1e-2) == IntervalVector([[6.25,6.70],[0.9,1.85]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[-6,-5],[0,2]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(b == IntervalVector([[-6,-5],[0,2]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[2,3],[-1,1]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(b == IntervalVector([[2,3],[-1,1]]))
+  
+  def test_CtcInverseNotIn_4(self):
+
+    v = VectorVar(1)
+    c = CtcInverseNotIn(AnalyticFunction([v], v), [[-1,1]])
+    x = IntervalVector(1)
+
+    c.contract(x)
+    self.assertTrue(x == IntervalVector(1))
+
+    x = IntervalVector([[0,8]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[1,8]]))
+  
+  def test_CtcInverseNotIn_5(self):
+
+    v = VectorVar(2)
+    c = CtcInverseNotIn(AnalyticFunction([v], v), IntervalVector([[-1,1],[5,6]]))
+    x = IntervalVector(2)
+
+    c.contract(x)
+    self.assertTrue(x == IntervalVector(2))
+
+    x = IntervalVector([[0,8],[5.5,oo]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,8],[5.5,oo]])) # unchanged
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcLazy.py

@@ -0,0 +1,50 @@
+#!/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 CtcCustom(Ctc_IntervalVector):
+
+  def __init__(self):
+    Ctc_IntervalVector.__init__(self, 2)
+
+  def contract(self, x):
+    if x[0].rad() > 1.:
+      return IntervalVector(x.mid()).inflate(0.5*x.rad())
+    return x
+
+
+class TestCtcLazy(unittest.TestCase):
+  
+  def test_CtcLazy(self):
+
+    ctc_custom = CtcCustom()
+    x = IntervalVector([[-1000,1000],[-1000,1000]])
+    x = ctc_custom.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-500,500],[-500,500]]))
+    x = ctc_custom.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-250,250],[-250,250]]))
+    x = ctc_custom.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-125,125],[-125,125]]))
+
+    ctc_lazy = CtcLazy(ctc_custom)
+    
+    x = IntervalVector([[-1000,1000],[-1000,1000]])
+    x = ctc_lazy.contract(x)
+    self.assertTrue(x == IntervalVector([[-250,250],[-250,250]]))
+    
+    x = IntervalVector([[-500,500],[-500,500]])
+    x = ctc_lazy.contract(x)
+    self.assertTrue(x == IntervalVector([[-125,125],[-125,125]]))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcPolygon.py

@@ -0,0 +1,91 @@
+#!/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 TestCtcPolygon(unittest.TestCase):
+
+  def test_CtcPolygon(self):
+
+    # Polygon, defined as a list of vertices
+    c = CtcPolygon([[3,-1],[3,4],[5,6],[-1,1]])
+
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,5],[-1,6]]))
+
+    x = IntervalVector([[3.02,3.16],[2.5,3.2]]) # possible bug
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+  def test_CtcPolygon_fromCodac1(self):
+
+    # Polygone with hole, defined as a list of edges
+
+    c = CtcPolygon([
+      # 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]]
+    ])
+
+    #DefaultFigure.pave(IntervalVector([[-10,10],[-10,10]]), c, 0.1)
+
+    # Check a box inside the hole
+
+    x = IntervalVector([[0],[0]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+    # Check a box inside the polygon
+
+    x = IntervalVector([[5],[-5]]).inflate(0.5)
+    _x = IntervalVector(x)
+    #DefaultFigure.draw_box(x,Color::purple())
+    c.contract(x)
+    self.assertTrue(x == _x)
+
+    # Check a box outside the polygon
+
+    x = IntervalVector([[-1],[8]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+
+    # Other polygon, defined as a list of vertices
+
+    c = CtcPolygon([[6,-6],[7,9],[0,5],[-9,8],[-8,-9]])
+
+    # Check a box inside the polygon
+
+    x = IntervalVector([[5],[-5]]).inflate(0.5)
+    _x = IntervalVector(x)
+    c.contract(x)
+    self.assertTrue(x == _x)
+
+    # Check a box outside the polygon
+
+    x = IntervalVector([[-1],[8]]).inflate(0.5)
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcSegment.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 TestCtcSegment(unittest.TestCase):
+  
+  def test_CtcSegment(self):
+
+    x = IntervalVector(2)
+    c = CtcSegment([[3],[-1]],[[3],[4]])
+
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[3,3],[-1,4]]))
+
+    x = IntervalVector([[3.0,3.16],[2.5,3.2]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[3,3],[2.5,3.2]]))
+
+    x = IntervalVector([[3.02,3.16],[2.5,3.2]])
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+    x = IntervalVector(2)
+    c = CtcSegment([[-1],[-1]],[[1],[1]])
+
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+
+    x = IntervalVector([[-oo,oo],[0]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0],[0]]))
+
+    x = IntervalVector([[0,oo],[0,oo]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,1],[0,1]]))
+
+    x = IntervalVector([[2,oo],[2,oo]])
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+  
+  def test_CtcSegment_fromCodac1(self):
+
+    # Test_CtcSegment01
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector([[-5,50],[-5, 50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,10],[0,20]]))
+
+    # Test_CtcSegment02
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector([[10,50],[20,50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[10,10],[20,20]]))
+
+    # Test_contract_degenerate
+
+    c = CtcSegment([[5],[5]], [[5],[5]])
+    x = IntervalVector([[-5,50],[-5,50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[5,5],[5,5]]))
+
+    # Test_contract_degenerate_x
+
+    c = CtcSegment([[5],[5]], [[10],[5]])
+    x = IntervalVector([[-50,50],[-50,50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[5,10],[5,5]]))
+
+    # Test_contract_degenerate_y
+
+    c = CtcSegment([[-5],[-5]], [[-5],[15]])
+    x = IntervalVector([Interval(-50, 50), Interval(-50, 50)])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[-5,-5],[-5,15]]))
+
+    # Test_contract_empty
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector([[-5,-2],[-5,50]])
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+    # Test_call_with_empty_x
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,10],[0,20]]))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Ellipsoid.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Morgan Louedec, (Simon Rohou)
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestEllipsoid(unittest.TestCase):
+
+  def test_Ellipsoid(self):
+    
+    self.assertTrue(True)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_GaussJordan.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+ 
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2025
+#  \author     Damien Massé
+#  \copyright  Copyright 2025 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestGaussJordan(unittest.TestCase):
+   
+    def test_GaussJordan(self):
+
+       M = Matrix([
+            [ 1, -4, 6, 7, 6 ],
+            [ 2,  1, 3, 6, -2 ],
+            [ 5,  2, 2, 9, -1 ] ])
+       pre = gauss_jordan(M)
+       # check that pre*M is "band matrix" */
+       P = pre*M
+       mx = 0.0
+       for i in range(1,M.rows()-1):
+          for j in range(0,i-1):
+             mx = max(mx,abs(P(i,j)))
+             mx = max(mx,abs(P(M.rows()-1-i,M.cols()-1-j)))
+       self.assertTrue(mx<1e-10)
+
+
+if __name__ ==  '__main__':
+  unittest.main()
+