codac4matlab 2.0.0.dev20__cp310-cp310-macosx_10_16_x86_64.whl → 2.0.0.dev25__cp310-cp310-macosx_10_16_x86_64.whl

codac4matlab/core/__init__.py

@@ -68,6 +68,9 @@ class AnalyticFunction:
 
   def tube_eval(self,*args):
     return self.f.tube_eval(*args)
+  
+  def parallelepiped_eval(self,*args):
+    return self.f.parallelepiped_eval(*args)
 
   def diff(self,*args):
     return self.f.diff(*args)
@@ -115,10 +118,10 @@ class CtcInverse(Ctc_IntervalVector):
       f_args = []
       for a in f.args():
         if a.size() == 1:
-          f_args.append(total_var[i])
+          f_args.append(total_var.get_item_0(i))
           i = i+1
         else:
-          f_args.append(total_var.subvector(i,i+a.size()-1))
+          f_args.append(total_var.subvector_0(i,i+a.size()-1))
           i = i+a.size()
 
       g = AnalyticFunction([total_var], f(*f_args))
@@ -153,9 +156,9 @@ class CtcInverse(Ctc_IntervalVector):
       for xi in x:
         k = xi.size()
         if k==1:
-          xi &= total[i]
+          xi &= total.get_item_0(i)
         else:
-          xi &= total.subvector(i,i+k-1)
+          xi &= total.subvector_0(i,i+k-1)
         i = i+k
       return x
 
@@ -171,17 +174,17 @@ class CtcInverse(Ctc_IntervalVector):
       for xi in x:
         k = xi.size()
         if k==1:
-          xi &= total[i]
+          xi &= total.get_item_0(i)
         else:
-          xi &= total.subvector(i,i+k-1)
+          xi &= total.subvector_0(i,i+k-1)
         i = i+k
       return x
 
   def copy(self):
     return self.c.copy()
 
-  def function(self):
-    return self.c.function()
+  def fnc(self):
+    return self.c.fnc()
 
 
 class CtcInverseNotIn(Ctc_IntervalVector):
@@ -413,8 +416,8 @@ class AnalyticTraj:
   def sampled(self, dt):
     return self.traj.sampled(dt)
     
-  def primitive(self, y0, t):
-    return self.traj.primitive(y0, t)
+  def primitive(self,*args):
+    return self.traj.primitive(*args)
     
   def as_function(self):
     return AnalyticFunction(self.traj.as_function())
@@ -479,6 +482,9 @@ class SlicedTube:
   def last_slice(self):
     return self.tube.last_slice()
 
+  def slice(self,*args):
+    return self.tube.slice(*args)
+
   def is_empty(self):
     return self.tube.is_empty()
 
@@ -488,8 +494,8 @@ class SlicedTube:
   def codomain(self):
     return self.tube.codomain()
 
-  def __call__(self,t):
-    return self.tube.__call__(t)
+  def __call__(self,*args):
+    return self.tube.__call__(*args)
 
   def enclosed_bounds(self,t):
     return self.tube.enclosed_bounds(t)
@@ -532,6 +538,18 @@ class SlicedTube:
 
   def primitive(self):
     return self.tube.primitive()
+    
+  def as_function(self):
+    return AnalyticFunction(self.tube.as_function())
+
+  def invert(self,*args):
+    return self.tube.invert(*args)
+
+  def all_reals_value(self):
+    return self.tube.all_reals_value()
+
+  def empty_value(self):
+    return self.tube.empty_value()
 
 
 def fixpoint(contract, *x):
@@ -547,7 +565,7 @@ def fixpoint(contract, *x):
       x = contract(x)
 
     if not isinstance(x,tuple):
-      vol = x[0].volume()
+      vol = x.get_item_0(0).volume()
     else:
       vol = 0.0
       for xi in x:
@@ -560,4 +578,11 @@ def fixpoint(contract, *x):
         if w != oo:
           vol += w
 
-  return x
+  return x
+
+
+# Deprecated function draw_while_paving(..)
+draw_while_paving = lambda *args, **kwargs: (_ for _ in ()).throw(
+    NotImplementedError("draw_while_paving(..) is deprecated,\n \
+      please replace by DefaultFigure.pave(..) (or any Figure2D object)")
+)

codac4matlab/tests/test_AnalyticTraj.py

@@ -13,7 +13,7 @@ import sys
 import math
 
 def prim_value(x):
-  return 1.+(1./3.)*math.pow(x,3)
+  return 0.+(1./3.)*math.pow(x,3)
 
 class TestAnalyticTraj(unittest.TestCase):
 
@@ -48,11 +48,10 @@ class TestAnalyticTraj(unittest.TestCase):
     self.assertTrue(Approx(sampled_traj(9.),1e-2) == 81.)
 
     # Testing primitive computation from analytic trajectory
-    x0 = f.real_eval(-1) # == 1.
-    sampled_prim_traj = traj.primitive(x0,0.01)
+    sampled_prim_traj = traj.primitive(0.01)
     self.assertTrue(sampled_prim_traj.tdomain() == Interval(-1,10))
     self.assertTrue(Approx(sampled_prim_traj.codomain(),4e-1) == Interval(prim_value(0),prim_value(10.)))
-    self.assertTrue(sampled_prim_traj(-1.) == x0)
+    self.assertTrue(sampled_prim_traj(-1.) == 0)
     self.assertTrue(Approx(sampled_prim_traj(0.),4e-1) == prim_value(0.))
     self.assertTrue(Approx(sampled_prim_traj(2.),4e-1) == prim_value(2.))
     self.assertTrue(Approx(sampled_prim_traj(5.),4e-1) == prim_value(5.))

codac4matlab/tests/test_BoolInterval.py

@@ -13,28 +13,84 @@ from codac import *
 class TestBoolInterval(unittest.TestCase):
 
   def test_BoolInterval(self):
-    
+
+    # Bitwise AND (&) — Intersection
     self.assertTrue((BoolInterval.TRUE & BoolInterval.TRUE) == BoolInterval.TRUE)
     self.assertTrue((BoolInterval.TRUE & BoolInterval.FALSE) == BoolInterval.EMPTY)
     self.assertTrue((BoolInterval.TRUE & BoolInterval.UNKNOWN) == BoolInterval.TRUE)
     self.assertTrue((BoolInterval.TRUE & BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
     self.assertTrue((BoolInterval.FALSE & BoolInterval.FALSE) == BoolInterval.FALSE)
     self.assertTrue((BoolInterval.FALSE & BoolInterval.UNKNOWN) == BoolInterval.FALSE)
     self.assertTrue((BoolInterval.FALSE & BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
     self.assertTrue((BoolInterval.EMPTY & BoolInterval.EMPTY) == BoolInterval.EMPTY)
     self.assertTrue((BoolInterval.EMPTY & BoolInterval.UNKNOWN) == BoolInterval.EMPTY)
+
     self.assertTrue((BoolInterval.UNKNOWN & BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
 
+    # Bitwise OR (|) — Union
     self.assertTrue((BoolInterval.TRUE | BoolInterval.TRUE) == BoolInterval.TRUE)
     self.assertTrue((BoolInterval.TRUE | BoolInterval.FALSE) == BoolInterval.UNKNOWN)
     self.assertTrue((BoolInterval.TRUE | BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
     self.assertTrue((BoolInterval.TRUE | BoolInterval.EMPTY) == BoolInterval.TRUE)
+
     self.assertTrue((BoolInterval.FALSE | BoolInterval.FALSE) == BoolInterval.FALSE)
     self.assertTrue((BoolInterval.FALSE | BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
     self.assertTrue((BoolInterval.FALSE | BoolInterval.EMPTY) == BoolInterval.FALSE)
+
     self.assertTrue((BoolInterval.EMPTY | BoolInterval.EMPTY) == BoolInterval.EMPTY)
     self.assertTrue((BoolInterval.EMPTY | BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
+
     self.assertTrue((BoolInterval.UNKNOWN | BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
 
+    # Logical AND (&&)
+    self.assertTrue(logical_and(BoolInterval.TRUE, BoolInterval.TRUE)  == BoolInterval.TRUE)
+    self.assertTrue(logical_and(BoolInterval.TRUE, BoolInterval.FALSE) == BoolInterval.FALSE)
+    self.assertTrue(logical_and(BoolInterval.TRUE, BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
+    self.assertTrue(logical_and(BoolInterval.TRUE, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    self.assertTrue(logical_and(BoolInterval.FALSE, BoolInterval.TRUE) == BoolInterval.FALSE)
+    self.assertTrue(logical_and(BoolInterval.FALSE, BoolInterval.FALSE) == BoolInterval.FALSE)
+    self.assertTrue(logical_and(BoolInterval.FALSE, BoolInterval.UNKNOWN) == BoolInterval.FALSE)
+    self.assertTrue(logical_and(BoolInterval.FALSE, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    self.assertTrue(logical_and(BoolInterval.UNKNOWN, BoolInterval.TRUE) == BoolInterval.UNKNOWN)
+    self.assertTrue(logical_and(BoolInterval.UNKNOWN, BoolInterval.FALSE) == BoolInterval.FALSE)
+    self.assertTrue(logical_and(BoolInterval.UNKNOWN, BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
+    self.assertTrue(logical_and(BoolInterval.UNKNOWN, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    self.assertTrue(logical_and(BoolInterval.EMPTY, BoolInterval.TRUE) == BoolInterval.EMPTY)
+    self.assertTrue(logical_and(BoolInterval.EMPTY, BoolInterval.FALSE) == BoolInterval.EMPTY)
+    self.assertTrue(logical_and(BoolInterval.EMPTY, BoolInterval.UNKNOWN) == BoolInterval.EMPTY)
+    self.assertTrue(logical_and(BoolInterval.EMPTY, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    # Logical OR (||)
+    self.assertTrue(logical_or(BoolInterval.TRUE, BoolInterval.TRUE)  == BoolInterval.TRUE)
+    self.assertTrue(logical_or(BoolInterval.TRUE, BoolInterval.FALSE) == BoolInterval.TRUE)
+    self.assertTrue(logical_or(BoolInterval.TRUE, BoolInterval.UNKNOWN) == BoolInterval.TRUE)
+    self.assertTrue(logical_or(BoolInterval.TRUE, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    self.assertTrue(logical_or(BoolInterval.FALSE, BoolInterval.TRUE) == BoolInterval.TRUE)
+    self.assertTrue(logical_or(BoolInterval.FALSE, BoolInterval.FALSE) == BoolInterval.FALSE)
+    self.assertTrue(logical_or(BoolInterval.FALSE, BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
+    self.assertTrue(logical_or(BoolInterval.FALSE, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    self.assertTrue(logical_or(BoolInterval.UNKNOWN, BoolInterval.TRUE) == BoolInterval.TRUE)
+    self.assertTrue(logical_or(BoolInterval.UNKNOWN, BoolInterval.FALSE) == BoolInterval.UNKNOWN)
+    self.assertTrue(logical_or(BoolInterval.UNKNOWN, BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
+    self.assertTrue(logical_or(BoolInterval.UNKNOWN, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    self.assertTrue(logical_or(BoolInterval.EMPTY, BoolInterval.TRUE) == BoolInterval.EMPTY)
+    self.assertTrue(logical_or(BoolInterval.EMPTY, BoolInterval.FALSE) == BoolInterval.EMPTY)
+    self.assertTrue(logical_or(BoolInterval.EMPTY, BoolInterval.UNKNOWN) == BoolInterval.EMPTY)
+    self.assertTrue(logical_or(BoolInterval.EMPTY, BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
+    # Complement (~)
+    self.assertTrue((~BoolInterval.TRUE) == BoolInterval.FALSE)
+    self.assertTrue((~BoolInterval.FALSE) == BoolInterval.TRUE)
+    self.assertTrue((~BoolInterval.UNKNOWN) == BoolInterval.UNKNOWN)
+    self.assertTrue((~BoolInterval.EMPTY) == BoolInterval.EMPTY)
+
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_ConvexPolygon.py

@@ -15,32 +15,32 @@ class TestConvexPolygon(unittest.TestCase):
   def test_ConvexPolygon_degenerate_base(self):
 
     p = ConvexPolygon([[1,2],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 1)
+    self.assertTrue(len(p.vertices()) == 1)
 
     p = ConvexPolygon([[1,3],[1,2],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.vertices()) == 2)
 
     p = ConvexPolygon([[1,2],[1,3],[1,2],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.vertices()) == 2)
 
     p = ConvexPolygon([[1,2],[1,3],[1,3],[1,2],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.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)
+    self.assertTrue(len(p.vertices()) == 1)
 
     p = ConvexPolygon([[1,2],[1,3]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.vertices()) == 2)
 
     p = ConvexPolygon([[1,2],[1,3],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.vertices()) == 2)
 
     p = ConvexPolygon([[1,2],[1,3],[1,2],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.vertices()) == 2)
 
     p = ConvexPolygon([[1,2],[1,3],[1,3],[1,2]])
-    self.assertTrue(len(p.unsorted_vertices()) == 2)
+    self.assertTrue(len(p.vertices()) == 2)
 
   def test_ConvexPolygon_degenerate_cases(self):
 
@@ -97,6 +97,8 @@ class TestConvexPolygon(unittest.TestCase):
     # Degenerate case
     p1 = ConvexPolygon([[4000,200]])
     p2 = ConvexPolygon(IntervalVector([4000,200]))
+    self.assertTrue(p1.box() == IntervalVector([4000,200]))
+    self.assertTrue(p2.box() == IntervalVector([4000,200]))
     self.assertTrue((p1 & p2) == p1) # same polygon
 
     p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
@@ -104,14 +106,14 @@ class TestConvexPolygon(unittest.TestCase):
     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)
+    self.assertTrue(len(q.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)
+    self.assertTrue(len(q.vertices()) == 4)
 
     # Degenerated box
     p1 = ConvexPolygon([[1,1],[2,4],[7,5],[6,2]])
@@ -133,35 +135,35 @@ class TestConvexPolygon(unittest.TestCase):
 
     q = p1 & p2
     self.assertTrue(Approx(q) == Polygon([[4,4.4],[4,1.6]]))
-    self.assertTrue(len(q.unsorted_vertices()) == 2)
+    self.assertTrue(len(q.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)
+    self.assertTrue(len(q.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)
+    self.assertTrue(len(q.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)
+    self.assertTrue(len(q.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(len(q.vertices()) == 0)
     self.assertTrue(q.is_empty())
 
     # Empty intersection, degenerate case
@@ -169,7 +171,7 @@ class TestConvexPolygon(unittest.TestCase):
     p2 = ConvexPolygon([[5,1.5],[80,2]])
     q = p1 & p2
     self.assertTrue(q == Polygon.empty())
-    self.assertTrue(len(q.unsorted_vertices()) == 0)
+    self.assertTrue(len(q.vertices()) == 0)
     self.assertTrue(q.is_empty())
 
     # Intersection of empty polygons
@@ -196,12 +198,103 @@ class TestConvexPolygon(unittest.TestCase):
     # 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)
+    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]))
 
+    # Parallel edges
+    p1 = ConvexPolygon([
+      [-1,-10],
+      [3,-10],
+      [3,1],
+      [-1,6],
+    ])
+    p2 = ConvexPolygon([
+      [-1,10],
+      [-1,-1],
+      [3,-6],
+      [3,10],
+    ])
+    q = p1 & p2
+    self.assertTrue(q == ConvexPolygon([
+      [3,-6],
+      [3,1],
+      [-1,6],
+      [-1,-1],
+    ]))
+
+    # Parallel edges towards infinity
+    p1 = ConvexPolygon([
+      [-1,next_float(-oo)],
+      [3,next_float(-oo)],
+      [3,1],
+      [-1,6],
+    ])
+    p2 = ConvexPolygon([
+      [-1,prev_float(oo)],
+      [-1,-1],
+      [3,-6],
+      [3,prev_float(oo)],
+    ])
+    q = p1 & p2
+    self.assertTrue(q == ConvexPolygon([
+      [3,-6],
+      [3,1],
+      [-1,6],
+      [-1,-1],
+    ]))
+
+    p1 = ConvexPolygon([[4,3.5],[5,4],[4,4.5]])
+    p2 = ConvexPolygon([[4,3.5],[5,3.5],[5,4.25],[4.5,4.25],[4,4]])
+    self.assertTrue(Approx(p1 & p2) == ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]]))
+
+    p1 = ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]])
+    p2 = ConvexPolygon(IntervalVector([[4,5],[4.1]]))
+    self.assertTrue(Approx(p1 & p2, 1e-10) == ConvexPolygon(IntervalVector([[4.2,4.8],[4.1]])))
+
+    p1 = ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]])
+    p2 = ConvexPolygon(IntervalVector([[4,5],Interval(41)/10]))
+    self.assertTrue(Approx(p1 & p2, 1e-10) == ConvexPolygon(IntervalVector([[4.2,4.8],Interval(41)/10])))
+
+    p1 = ConvexPolygon([
+      IntervalVector([[0.0999999, 0.100001],[0.989016, 0.989017]]),
+      IntervalVector([[0.0999999, 0.100001],[1.0015, 1.00151]]),
+      IntervalVector([[0, 0],[0.999999, 1]]),
+      IntervalVector([[0, 0],[1, 1.00001]])
+    ])
+
+    p2 = ConvexPolygon([
+      IntervalVector([[0, 0],[0.987514, 0.987515]]),
+      IntervalVector([[0.1, 0.100001],[0.989016, 0.989017]]),
+      IntervalVector([[0.1, 0.100001],[1.0015, 1.00151]]),
+      IntervalVector([[0, 0],[1.01248, 1.01249]]),
+    ])
+
+    self.assertTrue(Approx(p1 & p2, 1e-5) == ConvexPolygon([
+      [[0.0997289, 0.100002],[0.989016, 0.989938]],
+      [[0.0995829, 0.100002],[1.00059, 1.00151]],
+      [[0, 0],[0.999547, 1.00047]]
+    ]))
+
+    p1 &= p2
+
+    m = IntervalVector([6.5,1])
+    p1 = ConvexPolygon(m)
+    p2 = ConvexPolygon([
+      [[6.49999, 6.50001],[0.759358, 0.759359]],
+      [[6.49999, 6.50001],[1.19382, 1.19383]],
+      [[6.4, 6.40001],[1.20537, 1.20538]],
+      [[6.4, 6.40001],[0.78097, 0.780971]],
+    ])
+
+    s = Segment(IntervalVector([[6.49999, 6.50001],[0.759358, 0.759359]]), IntervalVector([[6.49999, 6.50001],[1.19382, 1.19383]]))
+    self.assertTrue(s.contains(m) == BoolInterval.UNKNOWN)
+    self.assertTrue((p1 & p2) == ConvexPolygon([m]))
+
+
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_CtcCtcBoundary.py

@@ -26,7 +26,7 @@ class TestCtcCtcBoundary(unittest.TestCase):
       | 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)
+    #DefaultFigure.pave(IntervalVector([[-2,2],[-2,2]]), ctc_diamond, 0.1)
 
     x = IntervalVector(2)
     ctc_diamond.contract(x)