codac4matlab 2.0.0.dev14__cp313-cp313-win32.whl

codac4matlab/tests/test_ConvexPolygon.py

@@ -0,0 +1,207 @@
+#!/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 TestConvexPolygon(unittest.TestCase):
+
+  def tests_ConvexPolygon_degenerate_base(self):
+
+    p = ConvexPolygon([[1,2],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 1)
+
+    p = ConvexPolygon([[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+    self.assertTrue(len(convex_hull([[1,2],[1,2],[1,2]])) == 1)
+    p = ConvexPolygon([[1,2],[1,2],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 1)
+
+    p = ConvexPolygon([[1,2],[1,3]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,2],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+    p = ConvexPolygon([[1,2],[1,3],[1,3],[1,2]])
+    self.assertTrue(len(p.unsorted_vertices()) == 2)
+
+  def tests_ConvexPolygon_degenerate_cases(self):
+
+    p1 = ConvexPolygon([[0,4]])
+    self.assertTrue(len(p1.edges()) == 1)
+    self.assertTrue(p1.edges()[0][0] == IntervalVector([0,4]))
+    self.assertTrue(p1.edges()[0][1] == IntervalVector([0,4]))
+
+    p1 = ConvexPolygon([[0,4],[2,8]])
+    self.assertTrue(len(p1.edges()) == 1)
+    self.assertTrue(p1.edges()[0][0] == IntervalVector([0,4]))
+    self.assertTrue(p1.edges()[0][1] == IntervalVector([2,8]))
+    self.assertTrue(p1 == ConvexPolygon([[2,8],[0,4]]))
+
+  def tests_ConvexPolygon_intersection(self):
+
+    p1 = ConvexPolygon([[0,4],[4,8],[7,0]])
+    p2 = ConvexPolygon([[-1,2],[-1,3],[5,3],[5,2]])
+    self.assertTrue((p1 & p2) == ConvexPolygon([
+        [3.5,2],[5,2],[5,3],[1.75,3]
+      ]))
+
+    p1 = ConvexPolygon([[3,2],[1,6],[6,5]])
+    p2 = ConvexPolygon(IntervalVector([[0,4],[0,4]]))
+    self.assertTrue((p1 & p2) == ConvexPolygon([
+        [3,2],[2,4],[4,4],[4,3]
+      ]))
+  
+    p1 = ConvexPolygon([[1,2],[3,4],[5,1],[2,1]])
+    p2 = ConvexPolygon(IntervalVector([[2,6],[2,6]]))
+    self.assertTrue(Approx(p1 & p2) == ConvexPolygon([
+        [2,2],[2,3],[3,4],[4.+1./3.,2.]
+      ]))
+
+    # Big box
+    p1 = ConvexPolygon([[1,2],[3,4],[5,1],[2,1]])
+    p2 = ConvexPolygon(IntervalVector([[-10,10],[-10,10]]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    # Inner box
+    p1 = ConvexPolygon([[1,2],[3,4],[5,1],[2,1]])
+    p2 = ConvexPolygon(IntervalVector([[2.8,3],[2.8,3]]))
+    self.assertTrue((p1 & p2) == p2) # same box
+
+    p1 = ConvexPolygon([[2,1],[3,1],[4,2],[4,3],[3,4],[2,4],[1,3],[1,2]])
+    p2 = ConvexPolygon(IntervalVector([[1,4],[1,4]]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    # Shifted polygon points declaration
+    p1 = ConvexPolygon([[3,4],[2,4],[1,3],[1,2],[2,1],[3,1],[4,2],[4,3]])
+    p2 = ConvexPolygon(IntervalVector([[1,4],[1,4]]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    # Degenerate case
+    p1 = ConvexPolygon([[4000,200]])
+    p2 = ConvexPolygon(IntervalVector([4000,200]))
+    self.assertTrue((p1 & p2) == p1) # same polygon
+
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon(IntervalVector([[2,6],[1,5]]))
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[2,1.2],[6,2],[6,4.8],[2,4]]))
+    self.assertTrue(len(q.edges()) == 4)
+    self.assertTrue(len(q.unsorted_vertices()) == 4)
+
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon(IntervalVector([[3,5],[1,5]]))
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[3,1.4],[5,1.8],[5,4.6],[3,4.2]]))
+    self.assertTrue(len(q.edges()) == 4)
+    self.assertTrue(len(q.unsorted_vertices()) == 4)
+
+    # Degenerated box
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon(IntervalVector([[4],[1,5]]))
+
+    self.assertTrue(p1.edges()[0] == Segment([[1,1],[6,2]]))
+    self.assertTrue(p1.edges()[1] == Segment([[6,2],[7,5]]))
+    self.assertTrue(p1.edges()[2] == Segment([[7,5],[2,4]]))
+    self.assertTrue(p1.edges()[3] == Segment([[2,4],[1,1]]))
+    self.assertTrue(len(p1.edges()) == 4)
+
+    self.assertTrue(p2.edges()[0] == Segment([[4,1],[4,5]]))
+    self.assertTrue(len(p2.edges()) == 1)
+
+    self.assertTrue((p1.edges()[1] & p2.edges()[0]) == IntervalVector.empty(2))
+    self.assertTrue(Approx(p1.edges()[0] & p2.edges()[0]) == IntervalVector([4,1.6]))
+    self.assertTrue((p1.edges()[3] & p2.edges()[0]) == IntervalVector.empty(2))
+    self.assertTrue(Approx(p1.edges()[2] & p2.edges()[0]) == IntervalVector([4,4.4]))
+
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[4,4.4],[4,1.6]]))
+    self.assertTrue(len(q.unsorted_vertices()) == 2)
+
+    # Degenerated polygon
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[4,1],[4,5]])
+    q = p1 & p2
+    self.assertTrue(Approx(q) == Polygon([[4,4.4],[4,1.6]]))
+    self.assertTrue(len(q.unsorted_vertices()) == 2)
+
+    # Point intersection
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[2,4],[-4,4],[0,8]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon([[2,4]]))
+    self.assertTrue(len(q.unsorted_vertices()) == 1)
+
+    # Point intersection, line polygon
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[2,4],[-4,4]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon([[2,4]]))
+    self.assertTrue(len(q.unsorted_vertices()) == 1)
+
+    # Empty intersection
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[5,1.5],[8,2],[8,0],[5,0]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(len(q.unsorted_vertices()) == 0)
+    self.assertTrue(q.is_empty())
+
+    # Empty intersection, degenerate case
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon([[5,1.5],[80,2]])
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(len(q.unsorted_vertices()) == 0)
+    self.assertTrue(q.is_empty())
+
+    # Intersection of empty polygons
+    p1 = ConvexPolygon.empty()
+    p2 = ConvexPolygon.empty()
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(q.is_empty())
+
+    # Intersection of a polygon and one empty polygon
+    p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
+    p2 = ConvexPolygon.empty()
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(q.is_empty())
+
+    # Intersection of a polygon and one empty polygon (line)
+    p1 = ConvexPolygon([[5,1.5],[80,2]])
+    p2 = ConvexPolygon.empty()
+    q = p1 & p2
+    self.assertTrue(q == Polygon.empty())
+    self.assertTrue(q.is_empty())
+
+    # Other test with inflated points
+    p1 = ConvexPolygon(IntervalVector([[-4,4],[-3,3]]))
+    a1,a2 = IntervalVector([-4,-6]), IntervalVector([-4,6])
+    a1.inflate(1e-10); a2.inflate(1e-10)
+    p2 = ConvexPolygon([Segment(a1,a2)])
+    q = p1 & p2
+    self.assertTrue(len(q.edges()) == 1)
+    self.assertTrue(Approx(q.edges()[0][0],1e-5) == IntervalVector([-4,-3]))
+    self.assertTrue(Approx(q.edges()[0][1],1e-5) == IntervalVector([-4,3]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcAction.py

@@ -0,0 +1,30 @@
+#!/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 TestCtcAction(unittest.TestCase):
+  
+  def tests_CtcAction(self):
+    
+    x = VectorVar(2)
+    c1 = CtcInverse(AnalyticFunction([x], x-IntervalVector([[1,5],[8,6]])), IntervalVector([[0],[0]]))
+
+    b = IntervalVector(2)
+    c1.contract(b)
+    self.assertTrue(b == IntervalVector([[1,5],[8,6]]))
+
+    c2 = CtcAction(c1, [2,-1])
+    b = IntervalVector(2)
+    c2.contract(b)
+    self.assertTrue(b == IntervalVector([[8,6],[-5,1]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcCartProd.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 TestCtcCartProd(unittest.TestCase):
+  
+  def tests_CtcCartProd(self):
+    
+    v = VectorVar(1)
+    c1 = CtcInverse(AnalyticFunction([v], v), IntervalVector([[-1,1]]))
+    c2 = CtcInverse(AnalyticFunction([v], v), IntervalVector([[5,6]]))
+
+    a = IntervalVector(1)
+    b = IntervalVector(1)
+    c1.contract(a)
+    self.assertTrue(a == IntervalVector([[-1,1]]))
+    c2.contract(b)
+    self.assertTrue(b == IntervalVector([[5,6]]))
+
+    x = IntervalVector(2)
+    c3 = CtcCartProd(c1,c2)
+    c3.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[5,6]]))
+
+    y = IntervalVector(2)
+    c4 = cart_prod(c1,c2)
+    c4.contract(y)
+    self.assertTrue(y == IntervalVector([[-1,1],[5,6]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcCtcBoundary.py

@@ -0,0 +1,48 @@
+#!/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 TestCtcCtcBoundary(unittest.TestCase):
+
+  def tests_CtcCtcBoundary(self):
+
+    ctc_bound_diamond = CtcSegment([[-1],[0]], [[0],[-1]]) | CtcSegment([[0],[-1]], [[1],[0]]) \
+      | CtcSegment([[1],[0]], [[0],[1]]) | CtcSegment([[0],[1]], [[-1],[0]])
+
+    ctc_diamond = CtcCtcBoundary(ctc_bound_diamond,test_inside_diamond)
+    #draw_while_paving(IntervalVector([[-2,2],[-2,2]]), ctc_diamond, 0.1)
+
+    x = IntervalVector(2)
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+
+    x = IntervalVector([[0,10],[0,10]])
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[0,1],[0,1]]))
+
+    x = IntervalVector([[0.2,10],[0.2,10]])
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[0.2,0.8],[0.2,0.8]]))
+
+    x = IntervalVector([[0.5,10],[0.5,10]])
+    ctc_diamond.contract(x)
+    #self.assertTrue(x == IntervalVector([[0.5],[0.5]]))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcFixpoint.py

@@ -0,0 +1,65 @@
+#!/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):
+
+  def __init__(self):
+    Ctc.__init__(self, 2)
+
+  def contract(self, x):
+    if x[0].rad() > 1.:
+      return IntervalVector(x.mid()).inflate(0.5*x.rad())
+    return x
+
+
+class TestCtcFixpoint(unittest.TestCase):
+  
+  def tests_CtcFixpoint(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_fixed = CtcFixpoint(ctc_custom, 0.)
+    
+    x = IntervalVector([[-1000,1000],[-1000,1000]])
+    ctc_fixed.contract(x)
+    self.assertTrue(Approx(x,1e-1) == IntervalVector([[-1,1],[-1,1]]))
+    x = IntervalVector([[-500,500],[-500,500]])
+    ctc_fixed.contract(x)
+    self.assertTrue(Approx(x,1e-1) == IntervalVector([[-1,1],[-1,1]]))
+
+    ctc_fixed = CtcFixpoint(ctc_custom, 0.8)
+    
+    x = IntervalVector([[-1000,1000],[-1000,1000]])
+    ctc_fixed.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-500,500],[-500,500]]))
+    ctc_fixed.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-250,250],[-250,250]]))
+
+    ctc_fixed = CtcFixpoint(ctc_custom, 1.)
+    
+    x = IntervalVector([[-1000,1000],[-1000,1000]])
+    ctc_fixed.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-500,500],[-500,500]]))
+    ctc_fixed.contract(x)
+    self.assertTrue(Approx(x) == IntervalVector([[-250,250],[-250,250]]))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

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 tests_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,157 @@
+#!/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 tests_CtcInverse_1(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], x[0]-x[1])
+    c = CtcInverse(f, 0)
+    self.assertTrue(c.function().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 tests_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 tests_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 tests_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 tests_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]]
+    #draw_while_paving(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]])
+
+if __name__ ==  '__main__':
+  unittest.main()