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

codac4matlab/tests/test_SampledTraj.py

@@ -0,0 +1,135 @@
+#!/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 *
+import sys, math, numpy as np
+
+class TestSampledTraj(unittest.TestCase):
+
+  def test_SampledTraj(self):
+
+    x = SampledVectorTraj({
+      0.25: [-0.5,0.5],
+      1.: [0,0],
+      2.: [1,0],
+      3.: [1,1],
+      4.: [-1,1],
+      5.: [-1,-1],
+      6.: [2,-1]
+    })
+
+    self.assertTrue(x.tdomain() == Interval(0.25,6))
+    self.assertTrue(x.size() == 2)
+    self.assertTrue(x.nb_samples() == 7)
+    self.assertTrue(not x.is_empty())
+    self.assertTrue(x.codomain() == IntervalVector([[-1,2],[-1,1]]))
+    self.assertTrue(x(0.25) == Vector([-0.5,0.5]))
+    self.assertTrue(x(1.) == Vector([0,0]))
+    self.assertTrue(x(6.) == Vector([2,-1]))
+    # Interpolations:
+    self.assertTrue(Approx(x(0.75)) == Vector([-1/6.,1/6.]))
+    self.assertTrue(x(1.5) == Vector([0.5,0]))
+    self.assertTrue(x(5.5) == Vector([0.5,-1]))
+    self.assertTrue(x(Interval(1,4)) == IntervalVector([[-1,1],[0,1]]))
+
+    x_sampled = x.sampled(0.1)
+    self.assertTrue(x_sampled.tdomain() == Interval(0.25,6))
+    self.assertTrue(x_sampled.size() == 2)
+    self.assertTrue(x_sampled.nb_samples() > 5*x.nb_samples()) # approx
+    self.assertTrue(not x_sampled.is_empty())
+    self.assertTrue(x_sampled.codomain() == IntervalVector([[-1,2],[-1,1]]))
+    self.assertTrue(x_sampled(0.25) == Vector([-0.5,0.5]))
+    self.assertTrue(x_sampled(1.) == Vector([0,0]))
+    self.assertTrue(x_sampled(6.) == Vector([2,-1]))
+    # Interpolations:
+    self.assertTrue(Approx(x_sampled(0.75)) == Vector([-1/6.,1/6.]))
+    self.assertTrue(Approx(x_sampled(1.5)) == Vector([0.5,0]))
+    self.assertTrue(Approx(x_sampled(5.5)) == Vector([0.5,-1]))
+    self.assertTrue(x_sampled(Interval(1,4)) == IntervalVector([[-1,1],[0,1]]))
+
+    #DefaultFigure.set_window_properties([75,75],[700,700])
+    #DefaultFigure.draw_trajectory(x, Color.blue())
+    #DefaultFigure.draw_trajectory(x_sampled, Color.red())
+
+    # SampledTraj as operator (1d case)
+    
+    t = ScalarVar()
+    f = AnalyticFunction(
+      [t], cos(t)
+    )
+    analytic_traj = AnalyticTraj(f, [-math.pi,math.pi])
+    sampled_traj = analytic_traj.sampled(1e-2)
+    g = sampled_traj.as_function()
+
+    h = AnalyticFunction(
+      [t], g(t)
+    )
+
+    t_ = -math.pi
+    while t_ < math.pi:
+      self.assertTrue(Approx(h.real_eval(t_),1e-8) == math.cos(t_))
+      t_=t_+1e-2
+
+    # SampledTraj as operator (nd case)
+
+    t = ScalarVar()
+    f = AnalyticFunction(
+      [t],
+      vec(2*cos(t),sin(2*t))
+    )
+
+    analytic_traj = AnalyticTraj(f, [0,5])
+    sampled_traj = analytic_traj.sampled(1e-2)
+    g = sampled_traj.as_function()
+
+    h = AnalyticFunction(
+      [t],
+      g(t)
+    )
+
+    t_ = 0
+    while t_ < 5:
+      self.assertTrue(Approx(h.real_eval(t_),1e-8) == Vector([2*math.cos(t_),math.sin(2*t_)]))
+      t_=t_+1e-2
+
+    h = AnalyticFunction(
+      [t],
+      [ g(t)[0],g(t)[1] ]
+    )
+
+    t_ = 0
+    while t_ < 5:
+      self.assertTrue(Approx(h.real_eval(t_),1e-8) == Vector([2*math.cos(t_),math.sin(2*t_)]))
+      t_=t_+1e-2
+
+    # SampledTraj (nan case)
+
+    x = SampledVectorTraj()
+    x.set(Vector([0,0]),0.)
+    x.set(Vector([2,2]),2.)
+    self.assertTrue(x(1.) == Vector([1,1]))
+    x.set(Vector([0,float("nan")]),0.)
+    self.assertTrue(x(1.).is_nan())
+
+    # SampledTraj, derivative
+
+    t = ScalarVar()
+    f = AnalyticFunction([t], sqr(t)*exp(sin(t)))
+    x = AnalyticTraj(f,[0,10]).sampled(1e-3)
+    s = AnalyticTraj(AnalyticFunction([t],exp(sin(t))*(2*t+sqr(t)*cos(t))),[0,10]).sampled(1e-2)
+
+    d = x.derivative()
+    p = d.primitive()
+
+    for i in np.arange(0, 10, 1e-1):
+      self.assertTrue(Approx(p(i),1e-2) == x(i))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Segment.py

@@ -0,0 +1,138 @@
+#!/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(prev_float(oo), oo)
+  else:
+    return Interval(x)
+
+
+class TestSegment(unittest.TestCase):
+
+  def test_contains(self):
+
+    p1 = Vector([0,-10])
+    p2 = Vector([-10,-10])
+    p3 = Vector([-11,-10])
+    e1 = Segment(Vector([-10,-10]), Vector([10,-10]))
+    self.assertTrue(e1.contains(p1) == BoolInterval.TRUE)
+    self.assertTrue(e1.contains(p2) == BoolInterval.TRUE)
+    self.assertTrue(e1.contains(p3) == BoolInterval.FALSE)
+
+  def test_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 test_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 test_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 test_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]))
+
+    # Near infinite cases
+    e1 = Segment([-1,6],[-1,next_float(-oo)])
+    e2 = Segment([-1,-1],[3,-6])
+    self.assertTrue((e1 & e2) == IntervalVector([-1,-1]))
+
+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 test_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 test_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)
+    #DefaultFigure.pave(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 test_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 test_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 test_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 test_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 test_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]]
+    ])
+
+    #DefaultFigure.pave(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 test_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.12421]]))
+
+    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 test_SepTransform(self):
+    
+    x = VectorVar(2)
+    s1 = SepInverse(AnalyticFunction([x], sqr(x[0])+sqr(x[1])), [0,1])
+    s2 = SepTransform(s1,
+      AnalyticFunction([x], x-Vector([2,2])),
+      AnalyticFunction([x], x+Vector([2,2])))
+
+    #DefaultFigure.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(),Color.purple(0.3)])
+    inner,outer = s2.separate(b)
+    #DefaultFigure.draw_box(xs.inner,[Color.green(),Color.green(0.3)])
+    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()