codac4matlab 2.0.0.dev20__cp311-cp311-win32.whl → 2.0.0.dev25__cp311-cp311-win32.whl

codac4matlab/tests/test_CtcDeriv.py

@@ -0,0 +1,434 @@
+#!/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 TestCtcDeriv(unittest.TestCase):
+  
+  def test_CtcDeriv(self):
+    
+    # Test slice, envelope contraction
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-10,20))
+    v = SlicedTube(tdomain, Interval(-1,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.t0_tf() == Interval(-1,3))
+    self.assertTrue(sx.codomain() == Interval(-10,20))
+    x.set([-1,2],-1)
+    x.set([-2,0],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate() == Interval(-1,2))
+    self.assertTrue(sx.output_gate() == Interval(-2,0))
+    self.assertTrue(sx.codomain() == Interval(-3.5,3))
+
+    # Test slice, output gate contraction
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-5,3))
+    v = SlicedTube(tdomain, Interval(-1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.t0_tf() == Interval(-1,3))
+    self.assertTrue(sx.codomain() == Interval(-5,3))
+    x.set([-1,3],-1)
+    x.set([-5,0.5],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate() == Interval(-1,3))
+    self.assertTrue(sx.output_gate() == Interval(-5,-1))
+    self.assertTrue(sx.codomain() == Interval(-5,3))
+
+    # Test slice, complete contraction (degenerate tube)
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-5,3))
+    v = SlicedTube(tdomain, Interval(-1,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.t0_tf() == Interval(-1,3))
+    self.assertTrue(sx.codomain() == Interval(-5,3))
+    x.set([1,3],-1)
+    x.set([-4,-3],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate() == Interval(1))
+    self.assertTrue(sx.output_gate() == Interval(-3))
+    self.assertTrue(sx.codomain() == Interval(-3,1))
+    self.assertTrue(sx(-1, sv) == Interval(1))
+    self.assertTrue(sx(1, sv) == Interval(-1))
+    self.assertTrue(sx(3, sv) == Interval(-3))
+    self.assertTrue(sx(0, sv) == Interval(0))
+
+    # Test slice, empty case
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-10,20))
+    v = SlicedTube(tdomain, Interval.empty())
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.t0_tf() == Interval(-1,3))
+    self.assertTrue(sx.codomain() == Interval(-10,20))
+    x.set([-1,2],-1)
+    x.set([-2,0],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate().is_empty())
+    self.assertTrue(sx.output_gate().is_empty())
+    self.assertTrue(sx.codomain().is_empty())
+
+    # Test slice, empty case (bis)
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-10,20))
+    v = SlicedTube(tdomain, Interval(-1,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.t0_tf() == Interval(-1,3))
+    self.assertTrue(sx.codomain() == Interval(-10,20))
+    x.set([-1,2],-1)
+    x.set(Interval.empty(),3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate().is_empty())
+    self.assertTrue(sx.output_gate().is_empty())
+    self.assertTrue(sx.codomain().is_empty())
+
+    # Test slice, unbounded slice
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval(0,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.input_gate() == Interval())
+    self.assertTrue(sx.output_gate() == Interval())
+    self.assertTrue(sx.codomain() == Interval())
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate() == Interval())
+    self.assertTrue(sx.output_gate() == Interval())
+    self.assertTrue(sx.codomain() == Interval())
+
+    # Test slice, unbounded derivative (1)
+  
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval())
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    self.assertTrue(sx.input_gate() == Interval())
+    self.assertTrue(sx.output_gate() == Interval())
+    self.assertTrue(sx.codomain() == Interval())
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate() == Interval())
+    self.assertTrue(sx.output_gate() == Interval())
+    self.assertTrue(sx.codomain() == Interval())
+
+    # Test slice, unbounded derivative ([-oo,1])
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval(-oo,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([-1,2],-1)
+    x.set([-2,0],3)
+
+    self.assertTrue(sx.input_gate() == Interval(-1,2))
+    self.assertTrue(sx.output_gate() == Interval(-2,0))
+    self.assertTrue(sx.codomain() == Interval())
+    self.assertTrue(sv.codomain() == Interval(-oo,1))
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    self.assertTrue(sx.input_gate() == Interval(-1,2))
+    self.assertTrue(sx.output_gate() == Interval(-2,0))
+    self.assertTrue(sx.codomain() == Interval(-6,6))
+    self.assertTrue(sv.codomain() == Interval(-oo,1))
+
+    # Test slice, unbounded derivative ([1,oo])
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval(-1,oo))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([-1,2],-1)
+    x.set([-2,0],3)
+
+    self.assertTrue(sx.input_gate() == Interval(-1,2))
+    self.assertTrue(sx.output_gate() == Interval(-2,0))
+    self.assertTrue(sx.codomain() == Interval())
+    self.assertTrue(sv.codomain() == Interval(-1,oo))
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+    
+    self.assertTrue(sx.input_gate() == Interval(-1,2))
+    self.assertTrue(sx.output_gate() == Interval(-2,0))
+    self.assertTrue(sx.codomain() == Interval(-5,4))
+    self.assertTrue(sv.codomain() == Interval(-1,oo))
+
+    # Test fwd
+
+    tdomain = create_tdomain([0,6],1.)
+    x_fwd = SlicedTube(tdomain, Interval())
+    x_fwd.set([-1,1],[0,1])
+    v = SlicedTube(tdomain, Interval(-0.5,1))
+    x_fwdbwd = SlicedTube(x_fwd)
+
+    ctc_deriv_fwd = CtcDeriv(TimePropag.FWD, False)
+    ctc_deriv_fwdbwd = CtcDeriv(TimePropag.FWD_BWD, False)
+
+    ctc_deriv_fwd.contract(x_fwd, v)
+    ctc_deriv_fwdbwd.contract(x_fwdbwd, v)
+    
+    self.assertTrue(x_fwd == x_fwdbwd)
+
+    # Checking structure
+    sx_fwd = [s for s in x_fwd if not s.is_gate()]
+
+    self.assertTrue(sx_fwd[0].codomain() == Interval(-1,1))
+    self.assertTrue(sx_fwd[1].codomain() == Interval(-1.5,2))
+    self.assertTrue(sx_fwd[2].codomain() == Interval(-2,3))
+    self.assertTrue(sx_fwd[3].codomain() == Interval(-2.5,4))
+    self.assertTrue(sx_fwd[4].codomain() == Interval(-3,5))
+    self.assertTrue(sx_fwd[5].codomain() == Interval(-3.5,6))
+    self.assertTrue(x_fwd.codomain() == Interval(-3.5,6))
+
+    # Test bwd
+
+    tdomain = create_tdomain([0,6],1.)
+    x_bwd = SlicedTube(tdomain, Interval())
+    x_bwd.set([-1,1],[5,6])
+    v = SlicedTube(tdomain, Interval(-1,0.5))
+    x_fwdbwd = SlicedTube(x_bwd)
+
+    ctc_deriv_bwd = CtcDeriv(TimePropag.BWD, False)
+    ctc_deriv_fwdbwd = CtcDeriv(TimePropag.FWD_BWD, False)
+
+    ctc_deriv_bwd.contract(x_bwd, v)
+    ctc_deriv_fwdbwd.contract(x_fwdbwd, v)
+    
+    self.assertTrue(x_bwd == x_fwdbwd)
+
+    # Checking structure
+    sx_bwd = [s for s in x_bwd if not s.is_gate()]
+    self.assertTrue(sx_bwd[0].codomain() == Interval(-3.5,6))
+    self.assertTrue(sx_bwd[1].codomain() == Interval(-3,5))
+    self.assertTrue(sx_bwd[2].codomain() == Interval(-2.5,4))
+    self.assertTrue(sx_bwd[3].codomain() == Interval(-2,3))
+    self.assertTrue(sx_bwd[4].codomain() == Interval(-1.5,2))
+    self.assertTrue(sx_bwd[5].codomain() == Interval(-1,1))
+    self.assertTrue(x_bwd.codomain() == Interval(-3.5,6))
+
+    # Test fwd/bwd
+
+    tdomain = create_tdomain([0,6],1.)
+    x = SlicedTube(tdomain, Interval())
+    x.set([-1,1],[0,1])
+    x.set([-1,1],[5,6])
+    v = SlicedTube(tdomain, Interval(-1,0.5))
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(x, v)
+
+    # Checking structure
+    sx = [s for s in x if not s.is_gate()]
+    self.assertTrue(sx[0].codomain() == Interval(-1,1))
+    self.assertTrue(sx[1].codomain() == Interval(-2,1.5))
+    self.assertTrue(Approx(sx[2].codomain()) == Interval(-7./3.,2.))
+    self.assertTrue(Approx(sx[3].codomain()) == Interval(-2.,7./3.))
+    self.assertTrue(sx[4].codomain() == Interval(-1.5,2.))
+    self.assertTrue(sx[5].codomain() == Interval(-1,1))
+    self.assertTrue(Approx(x.codomain()) == Interval(-7./3.,7./3.))
+
+    # Test fwd/bwd (example from tubint paper)
+
+    tdomain = create_tdomain([0,5],1.)
+    x = SlicedTube(tdomain, Interval())
+    x.set([0],0)
+    x.set([4],5)
+    v = SlicedTube(tdomain, Interval())
+    v.set([1,2],[0,1])
+    v.set([0.5,1.5],[1,2])
+    v.set([0,0.5],[2,3])
+    v.set([0],[3,4])
+    v.set([-0.5,0.5],[4,5])
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(x, v)
+
+    # Checking structure
+    sx = [s for s in x if not s.is_gate()]
+    self.assertTrue(sx[0].codomain() == Interval(0,2))
+    self.assertTrue(sx[1].codomain() == Interval(1.5,3.5))
+    self.assertTrue(sx[2].codomain() == Interval(3,4))
+    self.assertTrue(sx[3].codomain() == Interval(3.5,4))
+    self.assertTrue(sx[4].codomain() == Interval(3.5,4.25))
+    self.assertTrue(x.codomain() == Interval(0,4.25))
+
+    # Test fwd/bwd (other example)
+
+    tdomain = create_tdomain([0,26])
+    x = SlicedTube(tdomain, Interval(-1,7))
+    x.set([2,3],0)
+    x.set([3,4],4)
+    x.set([1],8)
+    x.set([1],12)
+    x.set([5.5],14)
+    x.set([5.5],16)
+    x.set([-1],18)
+    x.set([5.5],20)
+    x.set([5.5],23)
+    x.set([5.5],23) # setting gate again
+    v = SlicedTube(tdomain, Interval(-1,1))
+
+    sx = [s for s in x if not s.is_gate()]
+    sv = [s for s in v if not s.is_gate()]
+
+    sx[8].set([-oo,oo])
+
+    sv[0].set([-1.5,4])
+    sv[1].set([-0.75,-0.5])
+    sv[2].set([-1./3,1])
+    sv[3].set([4.5/2])
+    sv[4].set([0])
+    sv[5].set([-oo,-6.5/2])
+    sv[6].set([6.5/2,oo])
+    sv[7].set([-oo,oo])
+    sv[8].set([-oo,oo])
+
+    self.assertTrue(len(sx) == 9)
+    self.assertTrue(len(sv) == 9)
+    self.assertTrue(x.nb_slices() == 18)
+    self.assertTrue(v.nb_slices() == 18)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(x, v)
+
+    self.assertTrue(sx[0].codomain() == Interval(-1,7))
+    self.assertTrue(sx[1].codomain() == Interval(1,4))
+    self.assertTrue(Approx(sx[2].codomain()) == Interval(0,2))
+    self.assertTrue(sx[3].codomain() == Interval(1,5.5))
+    self.assertTrue(sx[4].codomain() == Interval(5.5))
+    self.assertTrue(x.codomain() == Interval(-oo,oo))
+
+    ctc_deriv.contract(sx[0], sv[0])
+    ctc_deriv.contract(sx[1], sv[1])
+    ctc_deriv.contract(sx[2], sv[2])
+    ctc_deriv.contract(sx[3], sv[3])
+    ctc_deriv.contract(sx[4], sv[4])
+    ctc_deriv.contract(sx[5], sv[5])
+    ctc_deriv.contract(sx[6], sv[6])
+    ctc_deriv.contract(sx[7], sv[7])
+    ctc_deriv.contract(sx[8], sv[8])
+
+    self.assertTrue(x(0.) == Interval(2,3))
+    self.assertTrue(sx[0].codomain() == Interval(-1,7))
+    self.assertTrue(x(4.) == Interval(3,4))
+    self.assertTrue(sx[1].codomain() == Interval(1,4))
+    self.assertTrue(x(8.) == Interval(1.))
+    self.assertTrue(Approx(sx[2].codomain()) == Interval(0,2))
+    self.assertTrue(x(12.) == Interval(1))
+    self.assertTrue(sx[3].codomain() == Interval(1,5.5))
+    self.assertTrue(x(14.) == Interval(5.5))
+    self.assertTrue(sx[4].codomain() == Interval(5.5))
+    self.assertTrue(x(16.) == Interval(5.5))
+    self.assertTrue(sx[5].codomain() == Interval(-1,5.5))
+    self.assertTrue(x(18.) == Interval(-1))
+    self.assertTrue(sx[6].codomain() == Interval(-1,5.5))
+    self.assertTrue(x(20.) == Interval(5.5))
+    self.assertTrue(sx[7].codomain() == Interval(-1,7))
+    self.assertTrue(x(23.) == Interval(5.5))
+
+    self.assertTrue(sx[8].codomain() == Interval())
+    self.assertTrue(x(26.) == Interval())
+    self.assertTrue(x.codomain() == Interval())
+
+    # From: Test slice, output gate contraction
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-5,3))
+    v = SlicedTube(tdomain, Interval(-1,-1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([-1,3],-1)
+    x.set([-5,0.5],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(x,v)
+
+    self.assertTrue(sx.input_gate() == Interval(-1,3))
+    self.assertTrue(sx.output_gate() == Interval(-5,-1))
+    self.assertTrue(sx(Interval(2.), sv) == Interval(-4,0))
+    self.assertTrue(sx(Interval(-1,3), sv) == Interval(-5,3))
+
+    # From: Test slice, complete contraction (degenerate tube)
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-5,3))
+    v = SlicedTube(tdomain, Interval(-1,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([1,3],-1)
+    x.set([-4,-3],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(x,v)
+
+    self.assertTrue(sx(Interval(0.5,2), sv) == Interval(-2,-0.5))
+    self.assertTrue(sx(Interval(1), sv) == Interval(-1))
+    self.assertTrue(sx(Interval(-1,3), sv) == Interval(-3,1))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcEval.py

@@ -0,0 +1,214 @@
+#!/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 TestCtcEval(unittest.TestCase):
+  
+  def test_CtcEval_1(self):
+
+    tdomain = create_tdomain([-1,7], 2., True)
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval())
+
+    self.assertTrue(x.nb_slices() == 9)
+
+    v.set_ith_slice([-1], 0*2+1)
+    v.set_ith_slice([-1,1], 1*2+1)
+    v.set_ith_slice([-1], 2*2+1)
+    v.set_ith_slice([-1,1], 3*2+1)
+
+    self.assertTrue(not v.is_empty())
+
+    t = Interval(0,6)
+    z = Interval(-1,1)
+
+    ctc_eval = CtcEval()
+    ctc_eval.contract(t, z, x, v)
+
+    self.assertTrue(x.nb_slices() == 13)
+
+    self.assertTrue(x(-1) == Interval())
+    self.assertTrue(x(0) == Interval(-2,7))
+    self.assertTrue(x(1) == Interval(-3,6))
+    self.assertTrue(x(3) == Interval(-4,4))
+    self.assertTrue(x(5) == Interval(-6,2))
+    self.assertTrue(x(6) == Interval(-7,2))
+    self.assertTrue(x(7) == Interval())
+
+  def test_CtcEval_2(self):
+    
+    t = ScalarVar()
+    fv = AnalyticFunction([t], -sin(t)+1e-3*Interval(-1,1))
+
+    tdomain = create_tdomain([0,20],0.1,True)
+    x = SlicedTube(tdomain, Interval(-10,10))
+    v = SlicedTube(tdomain, fv)
+    x.set(1,0)
+    
+    ctc_deriv = CtcDeriv()
+    ctc_deriv.contract(x, v)
+
+    ctc_eval = CtcEval()
+    xc = SlicedTube(x)
+    vc = SlicedTube(v)
+
+    y1 = IntervalVector([11.98,1])
+    ctc_eval.contract(y1[0], y1[1], xc, vc)
+
+    y2 = IntervalVector([6.5,1])
+    ctc_eval.contract(y2[0], y2[1], xc, vc)
+
+    ctc_deriv.contract(xc, vc)
+
+    self.assertTrue(xc(tdomain.t0_tf().lb()) == 1.)
+    self.assertTrue(xc(y1[0]) == y1[1])
+    self.assertTrue(xc(y2[0]) == y2[1])
+    self.assertTrue(Approx(xc(tdomain.t0_tf().ub()),1e-5) == Interval(0.294849,0.857381))
+
+  def test_CtcEval_3_from_tubeval(self):
+    
+    tdomain = create_tdomain([-PI,PI/2],1e-2,True)
+    t = ScalarVar()
+    fv = AnalyticFunction([t], cos(t)+Interval(-0.1,0.1))
+    v = SlicedTube(tdomain, fv)
+    x = v.primitive()
+    for sx in x:
+      if(not sx.is_gate()):
+        sx.set(sx.codomain() + Interval(-0.1,0.1))
+    for sx in x:
+      if(sx.is_gate()):
+        sx.set(sx.codomain() + Interval(-0.1,0.1))
+
+    ti = Interval(-0.5,0.3)
+    yi = Interval(0.3,1.1)
+
+    #DefaultFigure.plot_tube(x, [Color.light_gray(),Color.light_gray()])
+    #DefaultFigure.draw_box(cart_prod(ti,yi), Color.gray())
+
+    ctc_eval = CtcEval()
+    ctc_eval.contract(ti, yi, x, v)
+
+    #ctc_deriv = CtcDeriv()
+    #ctc_deriv.contract(x, v)
+
+    #DefaultFigure.plot_tube(x, [Color.dark_blue(),Color.blue()])
+    #DefaultFigure.draw_box(cart_prod(ti,yi), Color.red())
+
+    self.assertTrue(Approx(ti,1e-5) == Interval(-0.113064,0.3))
+    self.assertTrue(Approx(yi,1e-5) == Interval(0.299999,0.749899))
+    self.assertTrue(Approx(x.codomain(),1e-5) == Interval(-1.26758,1.58623))
+    self.assertTrue(Approx(v.codomain(),1e-4) == Interval(-1.10001,1.10001))
+    self.assertTrue(Approx(ti.lb(),1e-5) == -0.113063)
+    self.assertTrue(Approx(x(ti.lb()),1e-5) == Interval(-0.149899,0.300296))
+    self.assertTrue(Approx(ti.ub(),1e-5) == 0.3)
+    self.assertTrue(Approx(x(ti.ub()),1e-5) == Interval(0.299999,0.749899))
+
+  def test_CtcEval_4(self):
+    
+    tdomain = create_tdomain([0,11],1,True)
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval(-1.5,-1))
+
+    sx = []
+    for s in x:
+      if(not s.is_gate()):
+        sx.append(s)
+
+    sx[0].set([6,8])
+
+    ctc_eval = CtcEval()
+    ctc_deriv = CtcDeriv()
+    ctc_deriv.contract(x, v)
+
+    self.assertTrue(sx[0].codomain() == Interval(6,8)) 
+    self.assertTrue(sx[1].codomain() == Interval(4.5,7))
+    self.assertTrue(sx[2].codomain() == Interval(3,6))
+    self.assertTrue(sx[3].codomain() == Interval(1.5,5))
+    self.assertTrue(sx[4].codomain() == Interval(-0,4))
+    self.assertTrue(sx[5].codomain() == Interval(-1.5,3))
+    self.assertTrue(sx[6].codomain() == Interval(-3,2))
+    self.assertTrue(sx[7].codomain() == Interval(-4.5,1))
+    self.assertTrue(sx[8].codomain() == Interval(-6,0))
+    self.assertTrue(sx[9].codomain() == Interval(-7.5,-1))
+    self.assertTrue(sx[10].codomain() == Interval(-9,-2))
+
+    t = Interval()
+    y = Interval()
+    x_raw = SlicedTube(x)
+    v_raw = SlicedTube(v)
+
+    x = SlicedTube(x_raw)
+    v = SlicedTube(v_raw)
+    t = Interval(3.5,6)
+    y = Interval(3.5,6)
+    ctc_eval.contract(t, y, x, v)
+
+    sx.clear()
+    for s in x:
+      if(not s.is_gate()):
+        sx.append(s)
+
+    self.assertTrue(t == Interval(3.5,4.5))
+    self.assertTrue(y == Interval(3.5,4.5))
+    self.assertTrue(sx[0].codomain() == Interval(6,8))
+    self.assertTrue(sx[1].codomain() == Interval(4.5,7))
+    self.assertTrue(sx[2].codomain() == Interval(3,6))
+    self.assertTrue(sx[3].codomain() == Interval(1.5,5))
+    self.assertTrue(sx[3].t0_tf() == Interval(3,3.5))
+    self.assertTrue(sx[4].codomain() == Interval(2.75,4.75))
+    self.assertTrue(sx[4].t0_tf() == Interval(3.5,4))
+    self.assertTrue(sx[5].codomain() == Interval(2,4))
+    self.assertTrue(sx[5].t0_tf() == Interval(4,4.5))
+    self.assertTrue(sx[6].codomain() == Interval(0,4))
+    self.assertTrue(sx[6].t0_tf() == Interval(4.5,5))
+    self.assertTrue(sx[7].codomain() == Interval(-1.5,3))
+    self.assertTrue(sx[7].t0_tf() == Interval(5,6))
+
+    #ctc_deriv.contract(x, v)
+
+    #DefaultFigure.plot_tube(x_raw, [Color.light_gray(),Color.light_gray()])
+    #DefaultFigure.plot_tube(x, [Color.dark_blue(),Color.light_blue()])
+    #DefaultFigure.draw_line(Segment([[3.5,4.5],[11,4.5-1*(11-3.5)]]), Color.purple())
+    #DefaultFigure.draw_line(Segment([[3.5,3.5],[11,3.5-1.5*(11-3.5)]]), Color.purple())
+    #DefaultFigure.draw_box([[3.5,6],[3.5,6]], Color.light_gray())
+    #DefaultFigure.draw_box(cart_prod(t,y), Color.red())
+
+  def test_CtcEval_5_multi(self):
+    
+    tdomain = create_tdomain([0,10*PI],1e-1,True)
+    t = ScalarVar()
+    fv = AnalyticFunction([t], cos(t))
+    fx = AnalyticFunction([t], sin(t)+Interval(-0.1,0.1))
+    v = SlicedTube(tdomain, fv)
+    x = SlicedTube(tdomain, fx)
+
+    ctc_deriv = CtcDeriv()
+    ctc_deriv.contract(x, v)
+
+    #DefaultFigure.plot_tube(x, [Color.light_gray(),Color.light_gray()])
+
+    ti = Interval(11.42,23.15)
+    yi = Interval(-1.2,-1)
+    #DefaultFigure.draw_box(cart_prod(ti,yi), Color.gray())
+
+    ctc_eval = CtcEval()
+    ctc_eval.contract(ti,yi,x,v)
+    ctc_deriv.contract(x, v)
+
+    #DefaultFigure.plot_tube(x, [Color.blue(),Color.light_blue()])
+    #DefaultFigure.draw_box(cart_prod(ti,yi), Color.red())
+
+    self.assertTrue(ti == Interval(11.42,23.15))
+    self.assertTrue(Approx(yi) == Interval(-1.1,-1))
+    self.assertTrue(Approx(x(17.27),1e-4) == Interval(-1.10001,-0.897816))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcInverse.py

@@ -20,10 +20,17 @@ class TestCtcInverse(unittest.TestCase):
 
   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.function().input_size() == 2)
+    self.assertTrue(c.fnc().input_size() == 2)
 
     b = IntervalVector(2)
 
@@ -147,11 +154,13 @@ class TestCtcInverse(unittest.TestCase):
 
     ctc = CtcInverse(h, [0,0,0])
     x0 = [[0,1],[0,1],[0.05,0.18],[0.05,0.18]]
-    #draw_while_paving(x0, ctc, 0.001)
+    #DefaultFigure.pave(x0, ctc, 0.001)
     p = pave(x0, ctc, 0.01)
     cs = p.connected_subsets()
     self.assertTrue(len(cs) == 1)
-    self.assertTrue(Approx(cs[0].box(),1e-4) == [[0.149199,0.182388],[0.148306,0.1826],[0.148054,0.18],[0.148732,0.18]])
+    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):
 
@@ -201,4 +210,4 @@ class TestCtcInverse(unittest.TestCase):
     self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
 
 if __name__ ==  '__main__':
-  unittest.main()
+  unittest.main()

codac4matlab/tests/test_CtcPolygon.py

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