codac4matlab 2.0.0.dev20__cp39-cp39-win_amd64.whl → 2.0.0.dev25__cp39-cp39-win_amd64.whl

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()
+

codac4matlab/tests/test_IntFullPivLU.py

@@ -49,9 +49,36 @@ class TestIntvFullPivLU(unittest.TestCase):
       K = LUdec.kernel()
       self.assertTrue(K.cols()==1)
       self.assertTrue((M*K).norm().ub()<1e-10)
+      coK = LUdec.cokernel()
+      self.assertTrue(coK.rows()==1)
+      self.assertTrue((coK*M).norm().ub()<1e-10)
       Im = LUdec.image(M)
       self.assertTrue(Im.cols()==3)
+      coIm = LUdec.coimage(M)
+      self.assertTrue(coIm.rows()==3)
 
+   def test_IntvFullPivLU_3(self):
+      M = Matrix([
+      [ 1, -4, 6, 7, 6 ],
+      [ 2, 1, 3, 6, -2 ],
+      [ 5, 2, 8 , 9, -1 ]
+      ])
+      LUdec = IntvFullPivLU(M)
+      self.assertTrue(LUdec.is_injective()==BoolInterval.FALSE)
+      self.assertTrue(LUdec.is_surjective()==BoolInterval.TRUE)
+      self.assertTrue(LUdec.rank()==Interval(3))
+      self.assertTrue((LUdec.reconstructed_matrix()-M).norm().ub()<=1e-10)
+      K = LUdec.kernel()
+      self.assertTrue(K.cols()==2)
+      self.assertTrue((M*K).norm().ub()<1e-10)
+      Im = LUdec.image(M)
+      self.assertTrue(Im.cols()==3)
+      I1 = LUdec.solve(IntervalMatrix.eye(3,3));
+      self.assertTrue((M*I1-Matrix.eye(3,3)).norm().ub()<1e-10)
+      A = IntervalMatrix([ [1], [[-20,20]], [2], [[-20,20]], [[-20,20]] ])
+      B = IntervalMatrix([ [2.0], [1.0], [4.0] ])
+      LUdec.solve(B,A)
+      self.assertTrue((M*A-B).norm().ub()<=1e-10)
 
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_Interval.py

@@ -97,6 +97,10 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(x.mid() == 1)
     self.assertTrue(x.rad() == 1)
     self.assertTrue(x.diam() == 2)
+    self.assertTrue(x.mag() == 2)
+    self.assertTrue(x.mig() == 0)
+    self.assertTrue(x.smag() == 2)
+    self.assertTrue(x.smig() == 0)
 
     x = Interval(-3,-1)
 
@@ -105,6 +109,10 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(x.mid() == -2)
     self.assertTrue(x.rad() == 1)
     self.assertTrue(x.diam() == 2)
+    self.assertTrue(x.mag() == 3)
+    self.assertTrue(x.mig() == 1)
+    self.assertTrue(x.smag() == -3)
+    self.assertTrue(x.smig() == -1)
 
     x = Interval(-3,1)
 
@@ -113,6 +121,10 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(x.mid() == -1)
     self.assertTrue(x.rad() == 2)
     self.assertTrue(x.diam() == 4)
+    self.assertTrue(x.mag() == 3)
+    self.assertTrue(x.mig() == 0)
+    self.assertTrue(x.smag() == -3)
+    self.assertTrue(x.smig() == 0)
 
     x = Interval(-oo,0)
 
@@ -121,6 +133,10 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(x.mid() == -sys.float_info.max)
     self.assertTrue(x.rad() == oo)
     self.assertTrue(x.diam() == oo)
+    self.assertTrue(x.mag() == oo)
+    self.assertTrue(x.mig() == 0)
+    self.assertTrue(x.smag() == -oo)
+    self.assertTrue(x.smig() == 0)
 
     x = Interval(-oo,oo)
 
@@ -129,6 +145,10 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(x.mid() == 0)
     self.assertTrue(x.rad() == oo)
     self.assertTrue(x.diam() == oo)
+    self.assertTrue(x.mag() == oo)
+    self.assertTrue(x.mig() == 0)
+    self.assertTrue(x.smag() == oo)
+    self.assertTrue(x.smig() == 0)
 
     x = Interval(sys.float_info.max,oo)
 
@@ -137,17 +157,21 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(x.mid() == sys.float_info.max)
     self.assertTrue(x.rad() == oo)
     self.assertTrue(x.diam() == oo)
+    self.assertTrue(x.mag() == oo)
+    self.assertTrue(x.mig() == sys.float_info.max)
+    self.assertTrue(x.smag() == oo)
+    self.assertTrue(x.smig() == sys.float_info.max)
 
     x = Interval(-1,1)
     for i in range(10):
       self.assertTrue(x.contains(x.rand()))
-    x = Interval(-oo,0);
+    x = Interval(-oo,0)
     for i in range(10):
       self.assertTrue(x.contains(x.rand()))
-    x = Interval(0,oo);
+    x = Interval(0,oo)
     for i in range(10):
       self.assertTrue(x.contains(x.rand()))
-    x = Interval(-oo,oo);
+    x = Interval(-oo,oo)
     for i in range(10):
       self.assertTrue(x.contains(x.rand()))
     x = Interval.empty()
@@ -183,10 +207,10 @@ class TestInterval(unittest.TestCase):
     self.assertTrue(not Interval(0,next_float(0)).is_bisectable())
     self.assertTrue(Interval(0,next_float(next_float(0))).is_bisectable())
     self.assertTrue(Interval(10,next_float(next_float(10))).is_bisectable())
-    self.assertTrue(Interval(previous_float(previous_float(0)),0).is_bisectable())
-    self.assertTrue(Interval(previous_float(previous_float(10)),10).is_bisectable())
+    self.assertTrue(Interval(prev_float(prev_float(0)),0).is_bisectable())
+    self.assertTrue(Interval(prev_float(prev_float(10)),10).is_bisectable())
     self.assertTrue(not Interval(10,next_float(10)).is_bisectable())
-    self.assertTrue(not Interval(previous_float(0),0).is_bisectable())
+    self.assertTrue(not Interval(prev_float(0),0).is_bisectable())
 
     self.assertTrue(Interval(0,2).mid() == 1.0)
     self.assertTrue(Interval(-oo,oo).mid() == 0)

codac4matlab/tests/test_Interval_operations.py

@@ -88,13 +88,13 @@ class TestInterval_operations(unittest.TestCase):
   def test_interval_operations(self):
 
     self.assertTrue(0 < next_float(0))
-    self.assertTrue(0 > previous_float(0))
+    self.assertTrue(0 > prev_float(0))
     self.assertTrue(1 < next_float(1))
-    self.assertTrue(1 > previous_float(1))
+    self.assertTrue(1 > prev_float(1))
     self.assertTrue(oo == next_float(oo))
-    self.assertTrue(-oo == previous_float(-oo))
+    self.assertTrue(-oo == prev_float(-oo))
     self.assertTrue(-MAX_DOUBLE >= next_float(-oo))
-    self.assertTrue(MAX_DOUBLE <= previous_float(oo))
+    self.assertTrue(MAX_DOUBLE <= prev_float(oo))
     self.assertTrue(oo > MAX_DOUBLE)
     self.assertTrue(-oo < -MAX_DOUBLE)
     self.assertTrue(-Interval(0,1) == Interval(-1,0))
@@ -108,7 +108,7 @@ class TestInterval_operations(unittest.TestCase):
     self.CHECK_add(Interval(1,oo), Interval(0,1), Interval(1,oo))
     self.CHECK_add(Interval(-oo,oo), Interval(0,1), Interval(-oo,oo))
     self.CHECK_add(Interval(MAX_DOUBLE,oo), 1, Interval(MAX_DOUBLE,oo))
-    self.CHECK_add(Interval(MAX_DOUBLE,oo), -1, Interval(previous_float(MAX_DOUBLE),oo))
+    self.CHECK_add(Interval(MAX_DOUBLE,oo), -1, Interval(prev_float(MAX_DOUBLE),oo))
     self.CHECK_add(Interval(MAX_DOUBLE,oo), Interval(MAX_DOUBLE,oo), Interval(MAX_DOUBLE,oo))
     self.CHECK_add(Interval(MAX_DOUBLE,oo), -oo, Interval.empty())
     self.CHECK_add(Interval(MAX_DOUBLE,oo), oo, Interval.empty())
@@ -260,7 +260,7 @@ class TestInterval_operations(unittest.TestCase):
     self.assertTrue(Approx(atan2(Interval(-1),1)) == -Interval.pi()/4.0)
     self.assertTrue(Approx(atan2(Interval(1),-1)) == 3*Interval.pi()/4.0)
     self.assertTrue(Approx(atan2(Interval(0,oo),Interval(0,oo))) == Interval(0,1)*Interval.half_pi())
-    self.assertTrue(Approx(atan2(Interval(-oo,previous_float(0.0)),Interval(-oo,0))) == -(Interval.half_pi() | Interval.pi()))
+    self.assertTrue(Approx(atan2(Interval(-oo,prev_float(0.0)),Interval(-oo,0))) == -(Interval.half_pi() | Interval.pi()))
     self.assertTrue(Approx(atan2(Interval(-oo,0),Interval(0,oo))) == Interval(-1,0)*Interval.half_pi())
     self.assertTrue(Approx(atan2(Interval(0,oo),Interval(-oo,0))) == (Interval.half_pi() | Interval.pi()))
     self.assertTrue(Approx(atan2(Interval(1,oo),Interval(-1,1))) == (Interval.pi()/4.0 | 3*Interval.pi()/4.0))

codac4matlab/tests/test_OctaSym.py

@@ -28,5 +28,14 @@ class TestOctaSym(unittest.TestCase):
     c = OctaSym([-2,1,3])
     self.assertTrue(c.permutation_matrix() == Matrix([[0,-1,0],[1,0,0],[0,0,1]]))
 
+  def test_OctaSym_as_operator(self):
+
+    a = OctaSym([3,1,-2])
+    x = VectorVar(3)
+    f = AnalyticFunction([x], a(2*x))
+    self.assertTrue(f.eval(IntervalVector([[1],[2],[3]])) == IntervalVector([[6],[2],[-4]]))
+    self.assertTrue(f.eval(IntervalVector([[-oo,oo],[-oo,oo],[-oo,oo]])) == IntervalVector(3))
+    self.assertTrue(f.eval(IntervalVector.empty(3)) == IntervalVector.empty(3))
+
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_Parallelepiped.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2025
+#  \author     Maël Godard
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+import sys
+import math
+
+class TestParallelepiped(unittest.TestCase):
+
+  def test_parallelepiped(self):
+
+    p = Parallelepiped(Vector([0,2,4]), Matrix([[0.5,0,0],[0,1,0],[0,1,1]]))
+
+    self.assertTrue(p.box() == IntervalVector([[-0.5,0.5],[1,3],[2,6]]))
+    self.assertTrue((p.contains(Vector([0.1,2.1,4.1])))==BoolInterval.TRUE)
+    self.assertTrue((p.contains(Vector([20.,20.,20.])))==BoolInterval.FALSE)
+
+    self.assertTrue((p.is_superset(IntervalVector([[0.,0.1],[2.,2.1],[4.,4.1]])))==BoolInterval.TRUE)
+    self.assertTrue((p.is_superset(IntervalVector([[-10.,-9.],[15.,16.],[12.,13.]])))==BoolInterval.FALSE)
+    self.assertTrue((p.is_superset(IntervalVector([[0.,5.],[2.,7.],[4.,9.]])))==BoolInterval.UNKNOWN)
+
+    z = p.proj([2,1,0])
+    self.assertTrue(z.z == Vector([4,2,0]))
+    self.assertTrue(z.A == Matrix([[0,1,1],[0,1,0],[0.5,0,0]]))
+    self.assertTrue(z.box() == IntervalVector([[2,6],[1,3],[-0.5,0.5]]))
+      
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Parallelepiped_eval.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2025
+#  \author     Maël Godard
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+import sys
+import math
+
+class TestParallelepipedEval(unittest.TestCase):
+
+  def test_parallelepiped_eval(self):
+    x1 = ScalarVar()
+    x2 = ScalarVar()
+    x = VectorVar(2)
+
+    f1 = AnalyticFunction([x1], [x1,sqr(x1)])
+
+    f2 = AnalyticFunction([x1,x2], [x1, x2, sqr(x1)+sqr(x2)])
+    f3 = AnalyticFunction([x], [x[0], x[1], sqr(x[0])+sqr(x[1])])
+
+    p1a = f1.parallelepiped_eval(Interval(-0.1,0.1))
+    p1b = f1.parallelepiped_eval(1.0)
+    
+    self.assertTrue(Approx(p1a.z,1e-6)==Vector([0.0,0.0]))
+    self.assertTrue(Approx(p1a.A,1e-6)==Matrix([[0.12,0.0],[0.0,0.02]]))
+    self.assertTrue(Approx(p1b.z,1e-6)==Vector([1.0,1.0]))
+    self.assertTrue(Approx(p1b.A,1e-6)==Matrix([[0.0,0.0],[0.0,0.0]]))
+
+    pa = f2.parallelepiped_eval(Interval(-0.1,0.1), Interval(-0.1,0.1))
+    pb = f2.parallelepiped_eval(1.0,Interval(-1,1))
+
+    self.assertTrue(Approx(pa.z,1e-6)==Vector([0,0,0]))
+    self.assertTrue(Approx(pa.A,1e-6)==Matrix([[0.14,0,0],[0,0.14,0],[0,0,0.04]]))
+    self.assertTrue(Approx(pb.z,1e-6)==Vector([1,0,1]))
+    self.assertTrue(Approx(pb.A,1e-5)==Matrix([[0.894428,0,1.78886],[0,3,0],[1.78886,0,-0.894427]]))
+
+
+    dx = 0.4
+    x0 = -2.0
+    while x0<2.0:
+      X0 = Interval(x0,x0+dx)
+      y0 = -2.0
+      while y0<2.0:
+        Y0 = Interval(y0,y0+dx)
+        
+        p2 = f2.parallelepiped_eval(X0,Y0)
+        p3 = f3.parallelepiped_eval(IntervalVector([X0,Y0]))
+
+        self.assertTrue(Approx(p2.z,1e-6)==p3.z)
+        self.assertTrue(Approx(p2.A,1e-6)==p3.A)
+        y0 += dx
+      x0 += dx
+    
+      
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Polygon.py

@@ -34,8 +34,7 @@ class TestPolygon(unittest.TestCase):
     self.assertTrue(p1.contains(IntervalVector(2)) == BoolInterval.FALSE)
     self.assertTrue(p1.is_empty())
     self.assertTrue(len(p1.edges()) == 0)
-    self.assertTrue(len(p1.unsorted_vertices()) == 0)
-    self.assertTrue(len(p1.sorted_vertices()) == 0)
+    self.assertTrue(len(p1.vertices()) == 0)
 
   def test_Polygon(self):
 
@@ -104,5 +103,18 @@ class TestPolygon(unittest.TestCase):
     self.assertTrue(p4.contains(IntervalVector([1,3])) == BoolInterval.TRUE)
     self.assertTrue(p4.contains(IntervalVector([1,2])) == BoolInterval.TRUE)
 
+  def test_Polygon_limit_case(self):
+
+    x = Vector([5,3.5])
+    p = Polygon([[4,3.5],[5,4],[4,4.5]])
+    self.assertTrue(p.contains(x) == BoolInterval.FALSE)
+
+    p1 = ConvexPolygon([[4,3.5],[5,4],[4.5,4.25],[4,4]])
+    self.assertTrue(p1.contains([4.5,4.25]) == BoolInterval.TRUE)
+    p2 = ConvexPolygon([[4,4.25],[5,4.25]])
+    i = p1 & p2
+    self.assertTrue(i == ConvexPolygon(IntervalVector([4.5,4.25])))
+    self.assertTrue(len(i.vertices()) == 1)
+
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_SampledTraj.py

@@ -9,7 +9,7 @@
 
 import unittest
 from codac import *
-import sys, math
+import sys, math, numpy as np
 
 class TestSampledTraj(unittest.TestCase):
 
@@ -118,5 +118,18 @@ class TestSampledTraj(unittest.TestCase):
     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

@@ -14,13 +14,23 @@ def hull(x):
   if x == -oo:
     return Interval(-oo, next_float(-oo))
   if x == oo:
-    return Interval(previous_float(oo), oo)
+    return Interval(prev_float(oo), oo)
   else:
-    return INterval(x)
+    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)
@@ -119,5 +129,10 @@ class TestSegment(unittest.TestCase):
     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_SepCtcBoundary.py

@@ -26,7 +26,7 @@ class TestSepCtcBoundary(unittest.TestCase):
       | 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)
+    #DefaultFigure.pave(IntervalVector([[-2,2],[-2,2]]), sep_diamond, 0.1)
 
     x = IntervalVector(2)
     inner,outer = sep_diamond.separate(IntervalVector(2))

codac4matlab/tests/test_SepPolygon.py

@@ -52,7 +52,7 @@ class TestSepPolygon(unittest.TestCase):
       [[-3,-3], [-2,3]]
     ])
 
-    #draw_while_paving(IntervalVector([[-10,10],[-10,10]]), s, 0.1)
+    #DefaultFigure.pave(IntervalVector([[-10,10],[-10,10]]), s, 0.1)
 
     # Check a box inside the hole
 

codac4matlab/tests/test_SepTransform.py

@@ -17,10 +17,10 @@ class TestSepTransform(unittest.TestCase):
     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)))
+      AnalyticFunction([x], x-Vector([2,2])),
+      AnalyticFunction([x], x+Vector([2,2])))
 
-    #pave([[-5,5],[-5,5]], s2, 0.01)
+    #DefaultFigure.pave([[-5,5],[-5,5]], s2, 0.01)
 
     inner,outer = s2.separate(IntervalVector(2))
     self.assertTrue(inner == IntervalVector(2))
@@ -31,9 +31,9 @@ class TestSepTransform(unittest.TestCase):
     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())
+    #DefaultFigure.draw_box(b,[Color.purple(),Color.purple(0.3)])
     inner,outer = s2.separate(b)
-    #DefaultFigure.draw_box(xs.inner,Color.green())
+    #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]]))
 

codac4matlab/tests/test_Slice.py

@@ -0,0 +1,78 @@
+#!/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
+import math
+
+class TestSlice(unittest.TestCase):
+
+  def test_slice_inversion(self):
+
+    tdomain = create_tdomain([0,1])
+    x = SlicedTube(tdomain, Interval(0,10))
+    sx = x.first_slice()
+    x.set([2,3],0)
+    x.set([5,6],1)
+    self.assertTrue(sx.invert([4,6], 0) == Interval.empty())
+    self.assertTrue(sx.invert([2.5,6], 0) == 0.)
+    self.assertTrue(sx.invert([0,1], 1) == Interval.empty())
+    self.assertTrue(sx.invert([2.5,6], 1) == 1.)
+    self.assertTrue(sx.invert([2.5,6], [0.2,0.5]) == Interval(0.2,0.5))
+    self.assertTrue(sx.invert([2.5,6], 0.2) == Interval(0.2))
+
+  def test_slice_inversion_unbounded_derivative(self):
+
+    tdomain = create_tdomain([0,1])
+    x = SlicedTube(tdomain, Interval(0,10))
+    v = SlicedTube(tdomain, Interval())
+    sx = x.first_slice()
+    sv = v.first_slice()
+    self.assertTrue(sx.invert(5., sv, sx.t0_tf()) == Interval(0,1))
+    self.assertTrue(sx.invert(15., sv, sx.t0_tf()) == Interval.empty())
+
+  def test_slice_inversion_other_case(self):
+
+    tdomain = create_tdomain([6.4,6.5])
+    x = SlicedTube(tdomain, Interval(0.759,1.205))
+    v = SlicedTube(tdomain, Interval(-0.216,-0.115))
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([0.781,1.205],6.4)
+    x.set([0.759,1.194],6.5)
+
+    ctc_deriv = CtcDeriv()
+    ctc_deriv.contract(x,v)
+
+    self.assertTrue(not sx.codomain().is_empty())
+    self.assertTrue(Approx(sx.codomain(),1e-4) == Interval(0.7594, 1.20501))
+    self.assertTrue(Approx(sx.output_gate(),1e-4) == Interval(0.7594, 1.19351))
+
+    p = sx.polygon_slice(sv)
+
+    self.assertTrue(Approx(p,1e-4) == ConvexPolygon([
+      [[6.49999, 6.5],[0.7594, 0.759401]],
+      [[6.49999, 6.5],[1.1935, 1.19351]],
+      [[6.4, 6.40001],[1.20499, 1.20501]],
+      [[6.4, 6.40001],[0.780999, 0.781001]]
+    ]))
+
+    pt = IntervalVector([sx.t0_tf().ub(),1])
+
+    self.assertTrue(p.contains(pt) == BoolInterval.UNKNOWN)
+    self.assertTrue(p.box()[0].ub() == sx.t0_tf().ub())
+    
+    p_inter = (p&ConvexPolygon(pt))
+    self.assertTrue(p_inter == ConvexPolygon(pt))
+
+
+if __name__ ==  '__main__':
+  unittest.main()