codac4matlab 2.0.0.dev14__cp313-cp313-win32.whl

codac4matlab/tests/test_CtcInverseNotIn.py

@@ -0,0 +1,129 @@
+#!/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 TestCtcInverseNotIn(unittest.TestCase):
+
+  # Multivariable functions not supported (yet) for CtcInverseNotInNotIn: ScalarVar x,y
+  # Multivariable functions not supported (yet) for CtcInverseNotInNotIn: AnalyticFunction f { {x,y}, x-y }
+  # Multivariable functions not supported (yet) for CtcInverseNotInNotIn: CtcInverseNotInNotIn<Interval> c(f, Interval(0.))
+
+  def tests_CtcInverseNotIn_2(self):
+
+    # Test not really relevant, but copied from CtcInverse:
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0]-x[1]))
+    c = CtcInverseNotIn(f, [[0]])
+
+    #pave(IntervalVector([[-10,10],[-10,10]]), c, 0.1)
+
+    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([[1,5],[8,9]]))
+  
+  def tests_CtcInverseNotIn_3(self):
+
+    x = VectorVar(2)
+    f = AnalyticFunction([x], vec(x[0],sqr(x[0]/7.)+sqr(x[1]/3.)))
+    c = CtcInverseNotIn(f, [[0,oo],[1]])
+
+    b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[0,0.8],[-2.28,-1.56]]))
+
+    b = IntervalVector([[4,5.4],[-0.05,2.45]])
+    c.contract(b)
+    self.assertTrue(Approx(b,1e-2) == IntervalVector([[4,5.4],[-0.05,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.70],[0.9,1.85]]))
+
+    b = IntervalVector([[-6,-5],[0,2]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[-6,-5],[0,2]]))
+
+    b = IntervalVector([[2,3],[-1,1]])
+    c.contract(b)
+    self.assertTrue(b == IntervalVector([[2,3],[-1,1]]))
+  
+  # disabled: def tests_CtcInverseNotIn_3_CtcWrapper(self):
+  # disabled:   
+  # disabled:   x = VectorVar(2)
+  # disabled:   f = AnalyticFunction([x], vec(x[0],sqr(x[0]/7.)+sqr(x[1]/3.)))
+  # disabled:   c = CtcInverseNotIn(f, CtcWrapper([[0,oo],[1]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[0,0.8],[-2.28,-1.56]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(b == IntervalVector([[0,0.8],[-2.28,-1.56]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[4,5.4],[-0.05,2.45]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(Approx(b,1e-2) == IntervalVector([[4,5.4],[-0.05,2.45]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[6.25,6.7],[0.9,1.85]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(Approx(b,1e-2) == IntervalVector([[6.25,6.70],[0.9,1.85]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[-6,-5],[0,2]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(b == IntervalVector([[-6,-5],[0,2]]))
+  # disabled:   
+  # disabled:   b = IntervalVector([[2,3],[-1,1]])
+  # disabled:   c.contract(b)
+  # disabled:   self.assertTrue(b == IntervalVector([[2,3],[-1,1]]))
+  
+  def tests_CtcInverseNotIn_4(self):
+
+    v = VectorVar(1)
+    c = CtcInverseNotIn(AnalyticFunction([v], v), [[-1,1]])
+    x = IntervalVector(1)
+
+    c.contract(x)
+    self.assertTrue(x == IntervalVector(1))
+
+    x = IntervalVector([[0,8]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[1,8]]))
+  
+  def tests_CtcInverseNotIn_5(self):
+
+    v = VectorVar(2)
+    c = CtcInverseNotIn(AnalyticFunction([v], v), IntervalVector([[-1,1],[5,6]]))
+    x = IntervalVector(2)
+
+    c.contract(x)
+    self.assertTrue(x == IntervalVector(2))
+
+    x = IntervalVector([[0,8],[5.5,oo]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,8],[5.5,oo]])) # unchanged
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcLazy.py

@@ -0,0 +1,50 @@
+#!/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 TestCtcLazy(unittest.TestCase):
+  
+  def tests_CtcLazy(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_lazy = CtcLazy(ctc_custom)
+    
+    x = IntervalVector([[-1000,1000],[-1000,1000]])
+    x = ctc_lazy.contract(x)
+    self.assertTrue(x == IntervalVector([[-250,250],[-250,250]]))
+    
+    x = IntervalVector([[-500,500],[-500,500]])
+    x = ctc_lazy.contract(x)
+    self.assertTrue(x == IntervalVector([[-125,125],[-125,125]]))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcPolygon.py

@@ -0,0 +1,91 @@
+#!/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 TestCtcPolygon(unittest.TestCase):
+
+  def tests_CtcPolygon(self):
+
+    # Polygon, defined as a list of vertices
+    c = CtcPolygon([[3,-1],[3,4],[5,6],[-1,1]])
+
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,5],[-1,6]]))
+
+    x = IntervalVector([[3.02,3.16],[2.5,3.2]]) # possible bug
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+  def tests_CtcPolygon_fromCodac1(self):
+
+    # Polygone with hole, defined as a list of edges
+
+    c = CtcPolygon([
+      # 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]]
+    ])
+
+    #draw_while_paving(IntervalVector([[-10,10],[-10,10]]), c, 0.1)
+
+    # Check a box inside the hole
+
+    x = IntervalVector([[0],[0]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+    # Check a box inside the polygon
+
+    x = IntervalVector([[5],[-5]]).inflate(0.5)
+    _x = IntervalVector(x)
+    #DefaultFigure.draw_box(x,Color::purple())
+    c.contract(x)
+    self.assertTrue(x == _x)
+
+    # Check a box outside the polygon
+
+    x = IntervalVector([[-1],[8]]).inflate(0.5)
+    #DefaultFigure.draw_box(x,Color::purple())
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+
+    # Other polygon, defined as a list of vertices
+
+    c = CtcPolygon([[6,-6],[7,9],[0,5],[-9,8],[-8,-9]])
+
+    # Check a box inside the polygon
+
+    x = IntervalVector([[5],[-5]]).inflate(0.5)
+    _x = IntervalVector(x)
+    c.contract(x)
+    self.assertTrue(x == _x)
+
+    # Check a box outside the polygon
+
+    x = IntervalVector([[-1],[8]]).inflate(0.5)
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_CtcSegment.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 TestCtcSegment(unittest.TestCase):
+  
+  def tests_CtcSegment(self):
+
+    x = IntervalVector(2)
+    c = CtcSegment([[3],[-1]],[[3],[4]])
+
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[3,3],[-1,4]]))
+
+    x = IntervalVector([[3.0,3.16],[2.5,3.2]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[3,3],[2.5,3.2]]))
+
+    x = IntervalVector([[3.02,3.16],[2.5,3.2]])
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+    x = IntervalVector(2)
+    c = CtcSegment([[-1],[-1]],[[1],[1]])
+
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[-1,1],[-1,1]]))
+
+    x = IntervalVector([[-oo,oo],[0]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0],[0]]))
+
+    x = IntervalVector([[0,oo],[0,oo]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,1],[0,1]]))
+
+    x = IntervalVector([[2,oo],[2,oo]])
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+  
+  def tests_CtcSegment_fromCodac1(self):
+
+    # Test_CtcSegment01
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector([[-5,50],[-5, 50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,10],[0,20]]))
+
+    # Test_CtcSegment02
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector([[10,50],[20,50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[10,10],[20,20]]))
+
+    # Test_contract_degenerate
+
+    c = CtcSegment([[5],[5]], [[5],[5]])
+    x = IntervalVector([[-5,50],[-5,50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[5,5],[5,5]]))
+
+    # Test_contract_degenerate_x
+
+    c = CtcSegment([[5],[5]], [[10],[5]])
+    x = IntervalVector([[-50,50],[-50,50]])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[5,10],[5,5]]))
+
+    # Test_contract_degenerate_y
+
+    c = CtcSegment([[-5],[-5]], [[-5],[15]])
+    x = IntervalVector([Interval(-50, 50), Interval(-50, 50)])
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[-5,-5],[-5,15]]))
+
+    # Test_contract_empty
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector([[-5,-2],[-5,50]])
+    c.contract(x)
+    self.assertTrue(x.is_empty())
+
+    # Test_call_with_empty_x
+
+    c = CtcSegment([[0],[0]], [[10],[20]])
+    x = IntervalVector(2)
+    c.contract(x)
+    self.assertTrue(x == IntervalVector([[0,10],[0,20]]))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Ellipsoid.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Morgan Louedec, (Simon Rohou)
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+
+class TestEllipsoid(unittest.TestCase):
+
+  def tests_Ellipsoid(self):
+    
+    self.assertTrue(True)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_IntFullPivLU.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Damien Massé
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+
+import unittest
+from codac import *
+
+class TestIntvFullPivLU(unittest.TestCase):
+
+
+# bindings not implemented
+   def tests_IntvFullPivLU_1(self):
+      M = Matrix([
+      [ 1, -4, 3, 7 ],
+      [ 2, 1, -4, 6 ],
+      [ 5, 2, 1 , 9 ],
+      [ -1, 0, 3, 2 ]
+      ])
+
+      LUdec = IntvFullPivLU(M)
+      self.assertTrue(LUdec.is_injective()==BoolInterval.TRUE)
+      self.assertTrue(LUdec.is_surjective()==BoolInterval.TRUE)
+      self.assertTrue(LUdec.rank()==Interval(4))
+      self.assertTrue((LUdec.determinant()+602).mag()<=1e-10)
+      self.assertTrue((LUdec.reconstructed_matrix()-M).norm().ub()<=1e-10)
+      I1 = LUdec.solve(IntervalMatrix.eye(4,4));
+      self.assertTrue((I1*M-Matrix.eye(4,4)).norm().ub()<1e-10)
+
+   def tests_IntvFullPivLU_2(self):
+      M = Matrix([
+      [ 1, -4, 6, 7 ],
+      [ 2, 1, 3, 6 ],
+      [ 5, 2, 8 , 9 ],
+      [ -1, 0, -2, 2 ]
+      ])
+
+      LUdec = IntvFullPivLU(M)
+      self.assertTrue(LUdec.is_injective()==BoolInterval.UNKNOWN)
+      self.assertTrue(LUdec.is_surjective()==BoolInterval.UNKNOWN)
+      self.assertTrue(LUdec.rank()==Interval([3,4]))
+      self.assertTrue((LUdec.determinant()).mag()<=1e-10)
+      self.assertTrue((LUdec.reconstructed_matrix()-M).norm().ub()<=1e-10)
+      K = LUdec.kernel()
+      self.assertTrue(K.cols()==1)
+      self.assertTrue((M*K).norm().ub()<1e-10)
+      Im = LUdec.image(M)
+      self.assertTrue(Im.cols()==3)
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Interval.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+
+#  Codac tests
+#  
+#  Most of these tests come from the IBEX library (Gilles Chabert)
+#  See more: https://ibex-lib.readthedocs.io
+#  They have been revised to fit with Codac (v2)
+#
+# ----------------------------------------------------------------------------
+#  \date       2024
+#  \author     Gilles Chabert, (Simon Rohou)
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+import sys
+import math
+
+class TestInterval(unittest.TestCase):
+
+  def tests_interval(self):
+
+    self.assertTrue(Interval() == Interval(-oo,oo))
+    self.assertTrue(Interval(1.0) == Interval(1.0,1.0))
+    self.assertTrue(Interval(-oo) == Interval.empty())
+    self.assertTrue(Interval(oo) == Interval.empty())
+    self.assertTrue(Interval(1,0) == Interval.empty())
+
+    self.assertTrue(Interval(-oo,oo) == Interval(-oo,oo))
+    self.assertTrue(Interval(-oo,oo) != Interval(0,oo))
+    self.assertTrue(Interval(0,1) == Interval(0,1))
+    self.assertTrue(Interval(0,2) != Interval(0,1))
+    self.assertTrue(Interval(0,2) != Interval(1,3))
+    self.assertTrue(Interval(0,oo) == Interval(0,oo))
+    self.assertTrue(Interval.empty() == Interval.empty())
+    self.assertTrue(Interval(0,0) == Interval(0,0))
+
+    self.assertTrue(Interval([1.]) == Interval(1.));
+    self.assertTrue(Interval([2,3]) == Interval(2,3));
+    self.assertTrue(Interval([3,2]) == Interval.empty());
+    self.assertTrue(Interval([-oo]) == Interval.empty());
+    self.assertTrue(Interval([oo]) == Interval.empty());
+    self.assertTrue(Interval([oo,0]) == Interval.empty());
+    self.assertTrue(Interval([-oo,oo]) == Interval(-oo,oo));
+    self.assertTrue(Interval([oo,-oo]) == Interval.empty());
+
+    x = Interval() ; y = Interval() ; z = Interval()
+
+    x = Interval(0,1); x.set_empty()
+    self.assertTrue(x == Interval.empty())
+    self.assertTrue(x.is_empty())
+
+    x = Interval(Interval.empty()); x.set_empty()
+    self.assertTrue(x == Interval.empty())
+
+    x = Interval(0,1); y = Interval(2,3); z = Interval(0,3)
+    self.assertTrue((x|y) == z); self.assertTrue((y|x) == z)
+    x_ = x; x_|=y; self.assertTrue(x_ == z); y_ = y; y_|=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,1); y = Interval.empty(); z = Interval(0,1)
+    self.assertTrue((x|y) == z); self.assertTrue((y|x) == z)
+    x_ = x; x_|=y; self.assertTrue(x_ == z); y_ = y; y_|=x; self.assertTrue(y_ == z)
+
+    x = Interval(-1); y = Interval(0,oo); z = Interval(-1,oo)
+    self.assertTrue((x|y) == z); self.assertTrue((y|x) == z)
+    x_ = x; x_|=y; self.assertTrue(x_ == z); y_ = y; y_|=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,1); y = Interval(2,3); z = Interval.empty()
+    self.assertTrue((x&y) == z); self.assertTrue((y&x) == z)
+    x_ = x; x_&=y; self.assertTrue(x_ == z); y_ = y; y_&=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,1); y = Interval.empty(); z = Interval.empty()
+    self.assertTrue((x&y) == z); self.assertTrue((y&x) == z)
+    x_ = x; x_&=y; self.assertTrue(x_ == z); y_ = y; y_&=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,2); y = Interval(-1,1); z = Interval(0,1)
+    self.assertTrue((x&y) == z); self.assertTrue((y&x) == z)
+    x_ = x; x_&=y; self.assertTrue(x_ == z); y_ = y; y_&=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,1); y = Interval(0,oo); z = Interval(0,1)
+    self.assertTrue((x&y) == z); self.assertTrue((y&x) == z)
+    x_ = x; x_&=y; self.assertTrue(x_ == z); y_ = y; y_&=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,1); y = Interval(-oo,0); z = Interval(0)
+    self.assertTrue((x&y) == z); self.assertTrue((y&x) == z)
+    x_ = x; x_&=y; self.assertTrue(x_ == z); y_ = y; y_&=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,1); y = Interval(1,2); z = Interval(1,1)
+    self.assertTrue((x&y) == z); self.assertTrue((y&x) == z)
+    x_ = x; x_&=y; self.assertTrue(x_ == z); y_ = y; y_&=x; self.assertTrue(y_ == z)
+
+    x = Interval(0,2)
+
+    self.assertTrue(x.lb() == 0)
+    self.assertTrue(x.ub() == 2)
+    self.assertTrue(x.mid() == 1)
+    self.assertTrue(x.rad() == 1)
+    self.assertTrue(x.diam() == 2)
+
+    x = Interval(-3,-1)
+
+    self.assertTrue(x.lb() == -3)
+    self.assertTrue(x.ub() == -1)
+    self.assertTrue(x.mid() == -2)
+    self.assertTrue(x.rad() == 1)
+    self.assertTrue(x.diam() == 2)
+
+    x = Interval(-3,1)
+
+    self.assertTrue(x.lb() == -3)
+    self.assertTrue(x.ub() == 1)
+    self.assertTrue(x.mid() == -1)
+    self.assertTrue(x.rad() == 2)
+    self.assertTrue(x.diam() == 4)
+
+    x = Interval(-oo,0)
+
+    self.assertTrue(x.lb() == -oo)
+    self.assertTrue(x.ub() == 0)
+    self.assertTrue(x.mid() == -sys.float_info.max)
+    self.assertTrue(x.rad() == oo)
+    self.assertTrue(x.diam() == oo)
+
+    x = Interval(-oo,oo)
+
+    self.assertTrue(x.lb() == -oo)
+    self.assertTrue(x.ub() == oo)
+    self.assertTrue(x.mid() == 0)
+    self.assertTrue(x.rad() == oo)
+    self.assertTrue(x.diam() == oo)
+
+    x = Interval(sys.float_info.max,oo)
+
+    self.assertTrue(x.lb() == sys.float_info.max)
+    self.assertTrue(x.ub() == oo)
+    self.assertTrue(x.mid() == sys.float_info.max)
+    self.assertTrue(x.rad() == oo)
+    self.assertTrue(x.diam() == oo)
+
+    x = Interval(-1,1)
+    for i in range(10):
+      self.assertTrue(x.contains(x.rand()))
+    x = Interval(-oo,0);
+    for i in range(10):
+      self.assertTrue(x.contains(x.rand()))
+    x = Interval(0,oo);
+    for i in range(10):
+      self.assertTrue(x.contains(x.rand()))
+    x = Interval(-oo,oo);
+    for i in range(10):
+      self.assertTrue(x.contains(x.rand()))
+    x = Interval.empty()
+    self.assertTrue(math.isnan(x.rand()))
+
+    self.assertTrue(Interval(0,1).is_subset(Interval(0,2)))
+    self.assertTrue(not Interval(0,1).is_subset(Interval(1,2)))
+    self.assertTrue(not Interval(0,1).is_strict_interior_subset(Interval(0,2)))
+    self.assertTrue(Interval(-oo,0).is_strict_interior_subset(Interval(-oo,oo)))
+    self.assertTrue(Interval.empty().is_strict_interior_subset(Interval(0,1)))
+    self.assertTrue(Interval(0,2).is_superset(Interval(0,1)))
+    self.assertTrue(not Interval(1,2).is_superset(Interval(0,1)))
+    self.assertTrue(not Interval(0,2).is_strict_superset(Interval(0,2)))
+    self.assertTrue(Interval(-oo,oo).is_strict_superset(Interval(-oo,0)))
+    self.assertTrue(not Interval.empty().is_strict_superset(Interval.empty()))
+    self.assertTrue(Interval(0,2).contains(0))
+    self.assertTrue(Interval(-oo,oo).contains(oo))
+    self.assertTrue(not Interval(0,2).interior_contains(0))
+    self.assertTrue(Interval(0,2).interior_contains(1))
+    self.assertTrue(not Interval(-oo,0).is_disjoint(Interval(0,oo)))
+    self.assertTrue(Interval(0,1).is_disjoint(Interval(2,3)))
+    self.assertTrue(Interval(oo).is_empty())
+    self.assertTrue(not Interval(0,1).is_empty())
+    self.assertTrue(Interval(0).is_degenerated())
+    self.assertTrue(Interval.empty().is_degenerated())
+    self.assertTrue(not Interval.empty().is_unbounded())
+    self.assertTrue(not Interval(0,1).is_unbounded())
+    self.assertTrue(Interval(-oo,0).is_unbounded())
+    self.assertTrue(Interval(0,oo).is_unbounded())
+    self.assertTrue(not Interval.empty().is_bisectable())
+    self.assertTrue(not Interval(sys.float_info.max,oo).is_bisectable())
+    self.assertTrue(not Interval(-oo,-sys.float_info.max).is_bisectable())
+    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(not Interval(10,next_float(10)).is_bisectable())
+    self.assertTrue(not Interval(previous_float(0),0).is_bisectable())
+
+    self.assertTrue(Interval(0,2).mid() == 1.0)
+    self.assertTrue(Interval(-oo,oo).mid() == 0)
+    self.assertTrue(Interval(0,oo).mid() == sys.float_info.max)
+    self.assertTrue(Interval(-oo,0).mid() == -sys.float_info.max)
+    d = Interval(sys.float_info.max,oo).mid()
+    self.assertTrue((d == sys.float_info.max) or (d == -sys.float_info.max))
+    self.assertTrue(Interval(0).mid() == 0.0)
+
+    x = Interval(2.7629416257693772963,2.7629416257693835135)
+    y = x
+    m = x.mid()
+    x2 = x+m
+    x3 = x2-m
+    self.assertTrue(x3.is_superset(y))
+
+    self.assertTrue(Interval(0).diff(Interval(0)) == [])
+    self.assertTrue(Interval(0,0).diff(Interval(1,2)) == [Interval(0)])
+    self.assertTrue(Interval(0,0).diff(Interval(0,1)) == [])
+    self.assertTrue(Interval(0,0).diff(Interval.empty()) == [Interval(0)])
+    self.assertTrue(Interval.empty().diff(Interval(0.)) == [])
+    self.assertTrue(Interval(0,1).diff(Interval(0,1)) == [])
+    self.assertTrue(Interval(0,1).diff(Interval.empty()) == [Interval(0,1)])
+    self.assertTrue(Interval(0,1).diff(Interval(1,2)) == [Interval(0,1)])
+    self.assertTrue(Interval(0,1).diff(Interval(-1,1)) == [])
+    self.assertTrue(Interval(0,1).diff(Interval(0,0)) == [Interval(0,1)])
+    self.assertTrue(Interval(0,1).diff(Interval(1,1)) == [Interval(0,1)])
+    self.assertTrue(Interval(0,1).diff(Interval(2,3)) == [Interval(0,1)])
+    self.assertTrue(Interval(0,3).diff(Interval(1,2)) == [Interval(0,1),Interval(2,3)]) # order may not be respected
+    self.assertTrue(Interval(0,2).diff(Interval(1,4)) == [Interval(0,1)])
+    self.assertTrue(Interval(0,2).diff(Interval(-1,1)) == [Interval(1,2)])
+    self.assertTrue(Interval(0,2).diff(Interval(1,1), False) == [Interval(0,1),Interval(1,2)]) # order may not be respected
+    self.assertTrue(Interval(1,1).diff(Interval(0,2), False) == [])
+
+    a = Interval(3,8)
+    b = Interval(1,3) & Interval(6,7) # [b] is empty
+    c = a+b
+    self.assertTrue(c.is_empty())
+      
+if __name__ ==  '__main__':
+  unittest.main()