codac 2.0.0__cp314-cp314-win_amd64.whl

codac/__init__.py

@@ -0,0 +1,5 @@
+from codac.core import *
+from codac.graphics import *
+from codac.sympy import *
+from codac.unsupported import *
+from .version import __version__

codac/core/__init__.py

@@ -0,0 +1,459 @@
+#  Codac Python binding - main file
+# ----------------------------------------------------------------------------
+#  \date       2026
+#  \author     Simon Rohou
+#  \copyright  Copyright 2026 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+from codac._core import *
+import sys
+import warnings
+
+try:
+  import numpy as _np
+except ImportError:
+  _np = None
+
+
+def codac_error(message):
+  print(f'''
+=============================================================================
+The following Codac assertion failed:
+
+{message}
+
+You need help? Submit an issue on: https://github.com/codac-team/codac/issues
+=============================================================================
+  ''')
+  raise ValueError("")
+
+
+_ANALYTIC_FUNCTION_TYPES = (
+  AnalyticFunction_Scalar,
+  AnalyticFunction_Vector,
+  AnalyticFunction_Matrix,
+)
+
+_SLICEDTUBE_TYPES = (
+  SlicedTube_Interval,
+  SlicedTube_IntervalVector,
+  SlicedTube_IntervalMatrix,
+)
+
+_ANALYTIC_TRAJ_TYPES = (
+  AnalyticTraj_Scalar,
+  AnalyticTraj_Vector,
+  AnalyticTraj_Matrix,
+)
+
+_SAMPLED_TRAJ_TYPES = (
+  SampledTraj_Scalar,
+  SampledTraj_Vector,
+  SampledTraj_Matrix,
+)
+
+def _is_scalar_expr_like(x):
+  return isinstance(x, (int, float, Interval, ScalarVar, ScalarExpr))
+
+def _is_vector_expr_like(x):
+  return isinstance(x, (Vector, IntervalVector, VectorVar, VectorExpr))
+
+def _is_matrix_expr_like(x):
+  return isinstance(x, (Matrix, IntervalMatrix, MatrixVar, MatrixExpr))
+
+
+def _to_function_argument_expr(x):
+  if _is_scalar_expr_like(x):
+    return ScalarExpr(x)
+  if _is_vector_expr_like(x):
+    return VectorExpr(x)
+  if _is_matrix_expr_like(x):
+    return MatrixExpr(x)
+  codac_error("AnalyticFunction: invalid input arguments")
+
+
+def AnalyticFunction(args, e=None):
+  if e is None:
+    if isinstance(args, _ANALYTIC_FUNCTION_TYPES):
+      return args
+    codac_error("AnalyticFunction: invalid function argument")
+
+  if _is_scalar_expr_like(e):
+    return AnalyticFunction_Scalar(args, ScalarExpr(e))
+
+  if _is_vector_expr_like(e):
+    return AnalyticFunction_Vector(args, VectorExpr(e))
+
+  if _is_matrix_expr_like(e):
+    return AnalyticFunction_Matrix(args, MatrixExpr(e))
+
+  if isinstance(e, list):
+    lst = []
+    for e_i in e:
+      if _is_scalar_expr_like(e_i):
+        lst.append(ScalarExpr(e_i))
+      else:
+        codac_error("AnalyticFunction: invalid vectorial expression")
+    return AnalyticFunction_Vector(args, lst)
+
+  codac_error("AnalyticFunction: can only build functions from scalar or vector expressions")
+
+
+def _make_variadic_analytic_function_call(cpp_call):
+  def _call(self, *args):
+    if len(args) == 1 and isinstance(args[0], list):
+      args = tuple(args[0])
+
+    lst = []
+    for arg in args:
+      lst.append(_to_function_argument_expr(arg))
+    return cpp_call(self, lst)
+
+  return _call
+
+
+for _cls in _ANALYTIC_FUNCTION_TYPES:
+  _cls._codac_python_cpp_call = _cls.__call__
+  _cls.__call__ = _make_variadic_analytic_function_call(_cls._codac_python_cpp_call)
+
+
+class Ctc_IntervalVector(Ctc_IntervalVector_):
+
+  def __init__(self, n):
+    Ctc_IntervalVector_.__init__(self, n)
+
+  def copy(self):
+    return super().copy()
+
+
+class Sep(SepBase):
+
+  def copy(self):
+    return super().copy()
+
+
+def CtcInverse(f, y, with_centered_form=True):
+  f = AnalyticFunction(f)
+
+  if isinstance(f, AnalyticFunction_Scalar):
+    return CtcInverse_Interval(f, y, with_centered_form)
+
+  if isinstance(f, AnalyticFunction_Vector):
+    return CtcInverse_IntervalVector(f, y, with_centered_form)
+
+  codac_error("CtcInverse: can only build CtcInverse from scalar or vector functions")
+
+
+def CtcInverseNotIn(f, y, with_centered_form=True):
+  f = AnalyticFunction(f)
+
+  if isinstance(f, AnalyticFunction_Scalar):
+    return CtcInverseNotIn_Interval(f, y, with_centered_form)
+
+  if isinstance(f, AnalyticFunction_Vector):
+    return CtcInverseNotIn_IntervalVector(f, y, with_centered_form)
+
+  codac_error("CtcInverseNotIn: can only build CtcInverseNotIn from scalar or vector functions")
+
+
+def Approx(x, eps=sys.float_info.epsilon*10):
+  if isinstance(x, (int, float)):
+    return Approx_double(x, eps)
+  elif isinstance(x, Interval):
+    return Approx_Interval(x, eps)
+  elif isinstance(x, Vector):
+    return Approx_Vector(x, eps)
+  elif isinstance(x, IntervalVector):
+    return Approx_IntervalVector(x, eps)
+  elif isinstance(x, Matrix):
+    return Approx_Matrix(x, eps)
+  elif isinstance(x, IntervalMatrix):
+    return Approx_IntervalMatrix(x, eps)
+  elif isinstance(x, Segment):
+    return Approx_Segment(x, eps)
+  elif isinstance(x, (Polygon, ConvexPolygon)):
+    return Approx_Polygon(x, eps)
+  elif isinstance(x, tuple) and len(x) == 2 and isinstance(x[0], Interval) and isinstance(x[1], Interval):
+    return Approx_pair_Interval(x, eps)
+  else:
+    codac_error("Approx: invalid input")
+
+
+def hull(*args):
+  # -1: to be defined, 0: IntervalVector, 1: IntervalMatrix
+  lst = []
+  mode = -1
+
+  for arg in args:
+    if isinstance(arg, (Vector)):
+      mode = 0
+      lst.append(IntervalVector(arg))
+    elif isinstance(arg, (IntervalVector)):
+      mode = 0
+      lst.append(arg)
+    elif isinstance(arg, (Matrix)):
+      mode = 1
+      lst.append(IntervalMatrix(arg))
+    elif isinstance(arg, (IntervalMatrix)):
+      mode = 1
+      lst.append(arg)
+    elif isinstance(arg, (list)):
+      if isinstance(arg[0], (IntervalVector)):
+        return hull_intervalvector(arg)
+      elif isinstance(arg[0], (IntervalMatrix)):
+        return hull_intervalmatrix(arg)
+      else:
+        codac_error("hull: invalid input arguments")
+    else:
+      codac_error("hull: invalid input arguments")
+
+  if mode == 0:
+    return hull_intervalvector(lst)
+  return hull_intervalmatrix(lst)
+
+
+def cart_prod(*args):
+  # -1: to be defined, 0: vector, 1: intervalvector, 2: ctc, 3: sep
+  lst = []
+  mode = -1
+
+  for arg in args:
+
+    if isinstance(arg, (int, float, Vector)):
+      if mode == -1:
+        mode = 0
+
+    elif isinstance(arg, (list, Interval, IntervalVector)):
+      if mode != 2 and mode != 3:
+        mode = 1
+
+    elif isinstance(arg, (Ctc_IntervalVector, Ctc_IntervalVector_)):
+      mode = 2
+
+    elif isinstance(arg, (Sep, SepBase)):
+      mode = 3
+
+    else:
+      codac_error("cart_prod: invalid input arguments (a/" + str(mode) + ", " + str(arg) + ")")
+
+  for arg in args:
+
+    if isinstance(arg, (int, float)):
+      if mode == 0:
+        lst.append(Vector([arg]))
+      elif mode == 1:
+        lst.append(IntervalVector(Vector([arg])))
+      elif mode == 2:
+        lst.append(CtcWrapper(IntervalVector([arg])))
+      elif mode == 3:
+        lst.append(SepWrapper(IntervalVector([arg])))
+      else:
+        codac_error("cart_prod: invalid input arguments (b/" + str(mode) + ")")
+
+    elif isinstance(arg, (Vector)):
+      if mode == 0:
+        lst.append(arg)
+      elif mode == 1:
+        lst.append(IntervalVector(arg))
+      elif mode == 2:
+        lst.append(CtcWrapper(IntervalVector(arg)))
+      elif mode == 3:
+        lst.append(SepWrapper(IntervalVector(arg)))
+      else:
+        codac_error("cart_prod: invalid input arguments (c/" + str(mode) + ")")
+
+    elif isinstance(arg, (Interval)) or (isinstance(arg, list) and not isinstance(arg[0], list)):
+      if mode == 1:
+        lst.append(IntervalVector([arg]))
+      elif mode == 2:
+        lst.append(CtcWrapper(IntervalVector([arg])))
+      elif mode == 3:
+        lst.append(SepWrapper(IntervalVector([arg])))
+      else:
+        codac_error("cart_prod: invalid input arguments (d/" + str(mode) + ")")
+
+    elif isinstance(arg, (list, IntervalVector)) or (isinstance(arg, list) and isinstance(arg[0], list)):
+      if mode == 1:
+        lst.append(IntervalVector(arg))
+      elif mode == 2:
+        lst.append(CtcWrapper(IntervalVector(arg)))
+      elif mode == 3:
+        lst.append(SepWrapper(IntervalVector(arg)))
+      else:
+        codac_error("cart_prod: invalid input arguments (e/" + str(mode) + ")")
+
+    elif isinstance(arg, (Ctc_IntervalVector, Ctc_IntervalVector_)):
+      if mode != 2:
+        codac_error("cart_prod: invalid input arguments (f/" + str(mode) + ")")
+      lst.append(arg)
+
+    elif isinstance(arg, (Sep, SepBase)):
+      if mode != 3:
+        codac_error("cart_prod: invalid input arguments (g/" + str(mode) + ")")
+      lst.append(arg)
+
+    else:
+      mode = -2  # will generate an error
+
+  if mode == 0:
+    return cart_prod_vector(lst)
+  if mode == 1:
+    return cart_prod_intervalvector(lst)
+  if mode == 2:
+    return cart_prod_ctc(lst)
+  if mode == 3:
+    return cart_prod_sep(lst)
+  codac_error("cart_prod: invalid input arguments (h/" + str(mode) + ")")
+
+
+def tube_cart_prod(*x):
+  if not isinstance(x, tuple):
+    return tube_cart_prod_list([x])
+  return tube_cart_prod_list([*x])
+
+
+def traj_cart_prod(*x):
+  if not isinstance(x, tuple):
+    return traj_cart_prod_list([x])
+  return traj_cart_prod_list([*x])
+
+
+def _sampled_traj_type_and_value(x):
+  if isinstance(x, (int, float)):
+    return SampledTraj_Scalar, float
+
+  if isinstance(x, Vector) \
+      or (_np is not None and isinstance(x, _np.ndarray) and x.ndim == 1) \
+      or (isinstance(x, (list, tuple)) and (len(x) == 0 or not isinstance(x[0], (list, tuple)))):
+    return SampledTraj_Vector, lambda y: y if isinstance(y, Vector) else Vector(y)
+
+  if isinstance(x, Matrix) \
+      or (_np is not None and isinstance(x, _np.ndarray) and x.ndim == 2) \
+      or (isinstance(x, (list, tuple)) and len(x) > 0 and isinstance(x[0], (list, tuple))):
+    return SampledTraj_Matrix, lambda y: y if isinstance(y, Matrix) else Matrix(y)
+
+  return None, None
+
+
+def SampledTraj(x=None, y=None):
+  if y is None:
+    if x is None:
+      codac_error("SampledTraj: unable to deduce the trajectory type from an empty constructor")
+
+    for cls in _SAMPLED_TRAJ_TYPES:
+      if isinstance(x, cls):
+        return cls(dict(x))
+
+    if isinstance(x, dict):
+      if not x:
+        codac_error("SampledTraj: unable to deduce the trajectory type from an empty map")
+      cls, cast = _sampled_traj_type_and_value(next(iter(x.values())))
+      if cls is None:
+        codac_error("SampledTraj: wrong constructor argument")
+      return cls({float(t): cast(v) for t, v in x.items()})
+
+    codac_error("SampledTraj: wrong constructor argument")
+
+  if len(y) == 0:
+    codac_error("SampledTraj: unable to deduce the trajectory type from empty samples")
+
+  cls, cast = _sampled_traj_type_and_value(y[0])
+  if cls is None:
+    codac_error("SampledTraj: unable to deduce the trajectory type from the provided samples")
+
+  if cls is SampledTraj_Scalar:
+    return cls(list(x), [float(v) for v in y])
+
+  if cls is SampledTraj_Vector and _np is not None and isinstance(x, _np.ndarray) and isinstance(y, _np.ndarray):
+    return cls(x, y)
+
+  return cls({float(t): cast(v) for t, v in zip(x, y)})
+
+
+def AnalyticTraj(t,f):
+
+  if isinstance(t, _ANALYTIC_FUNCTION_TYPES) and not isinstance(f, _ANALYTIC_FUNCTION_TYPES):
+    warnings.warn(
+      "AnalyticTraj(f,t) is deprecated; use AnalyticTraj(t,f) instead.",
+      FutureWarning,
+      stacklevel=2
+    )
+    t,f = f,t
+
+  f = AnalyticFunction(f)
+
+  if isinstance(f, AnalyticFunction_Scalar):
+    return AnalyticTraj_Scalar(t,f)
+
+  if isinstance(f, AnalyticFunction_Vector):
+    return AnalyticTraj_Vector(t,f)
+
+  if isinstance(f, AnalyticFunction_Matrix):
+    return AnalyticTraj_Matrix(t,f)
+
+  codac_error("AnalyticTraj: can only build this trajectory from an AnalyticFunction_[Scalar/Vector/Matrix]")
+
+
+def SlicedTube(x, y=None):
+
+  if y is None:
+    if isinstance(x, SlicedTube_Interval):
+      return SlicedTube_Interval(x)
+    if isinstance(x, SlicedTube_IntervalVector):
+      return SlicedTube_IntervalVector(x)
+    if isinstance(x, SlicedTube_IntervalMatrix):
+      return SlicedTube_IntervalMatrix(x)
+    codac_error("SlicedTube: unable to copy this tube from another one")
+
+  y = AnalyticFunction(y) if isinstance(y, _ANALYTIC_FUNCTION_TYPES) else y
+
+  if isinstance(y, (Interval, AnalyticFunction_Scalar, AnalyticTraj_Scalar, SampledTraj_Scalar)):
+    return SlicedTube_Interval(x, y)
+
+  if isinstance(y, (IntervalVector, AnalyticFunction_Vector, AnalyticTraj_Vector, SampledTraj_Vector)):
+    return SlicedTube_IntervalVector(x, y)
+
+  if isinstance(y, (IntervalMatrix, AnalyticFunction_Matrix, AnalyticTraj_Matrix, SampledTraj_Matrix)):
+    return SlicedTube_IntervalMatrix(x, y)
+
+  codac_error("SlicedTube: wrong constructor argument")
+
+
+def fixpoint(contract, *x):
+  vol = -1.0
+  prev_vol = None
+
+  while vol != prev_vol:
+
+    prev_vol = vol
+    if type(x) is tuple:
+      x = contract(*x)
+    else:  # prevent from unpacking
+      x = contract(x)
+
+    # For computing the volume:
+    # only a real Python tuple is considered as a collection of objects.
+    # Otherwise, any iterable object (tube, boxes, etc.) will be divided in the for loop.
+    items = x if type(x) is tuple else (x,)
+
+    vol = 0.0
+    for xi in items:
+      if xi.is_empty():
+        return x
+      w = xi.volume()
+      # As infinity is absorbent, this would not
+      # allow us to identify a contraction, so we
+      # exclude these cases:
+      if w != oo:
+        vol += w
+
+  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)"
+  )
+)

codac/graphics/__init__.py

@@ -0,0 +1 @@
+from codac._graphics import *

codac/sympy/__init__.py

@@ -0,0 +1,2 @@
+from codac._core._sympy import *
+from codac import AnalyticFunction, AnalyticFunction_Scalar, AnalyticFunction_Vector, AnalyticFunction_Matrix

codac/tests/__init__.py

@@ -0,0 +1 @@
+# Codac tests are placed in this folder (see python/CMakeLists.txt)

codac/tests/codac2_tests_predefined_tubes.py

@@ -0,0 +1,193 @@
+from codac import *
+
+def tube_test_1():
+
+  x = SlicedTube(create_tdomain([0.,46.], 1., False), Interval())
+  x.set_ith_slice([4,8], 0)
+  x.set_ith_slice([2,7], 1)
+  x.set_ith_slice([1,6], 2)
+  x.set_ith_slice([-4,4], 3)
+  x.set_ith_slice([-7,-1], 4)
+  x.set_ith_slice([-9,-5], 5)
+  x.set_ith_slice([-10,-6], 6)
+  x.set_ith_slice([-11,-7], 7)
+  x.set_ith_slice([-10,-6], 8)
+  x.set_ith_slice([-9,-4], 9)
+  x.set_ith_slice([-8,-5], 10)
+  x.set_ith_slice([-7,-4], 11)
+  x.set_ith_slice([-6,-2], 12)
+  x.set_ith_slice([-5,-1], 13)
+  x.set_ith_slice([-5,3], 14) # to be updated
+  x.set_ith_slice([-2,4], 15)
+  x.set_ith_slice([0,6], 16)
+  x.set_ith_slice([2,7], 17)
+  x.set_ith_slice([4,8], 18)
+  x.set_ith_slice([6,9], 19)
+  x.set_ith_slice([7,10], 20)
+  x.set_ith_slice([8,11], 21)
+  x.set_ith_slice([9,12], 22)
+  x.set_ith_slice([8,13], 23)
+  x.set_ith_slice([7,12], 24)
+  x.set_ith_slice([5,11], 25)
+  x.set_ith_slice([3,10], 26)
+  x.set_ith_slice([4,9], 27)
+  x.set_ith_slice([5,8], 28)
+  x.set_ith_slice([4,7], 29)
+  x.set_ith_slice([3,6], 30)
+  x.set_ith_slice([3,5], 31)
+  x.set_ith_slice([2,5], 32)
+  x.set_ith_slice([2,5], 33)
+  x.set_ith_slice([1,5], 34)
+  x.set_ith_slice([2,4], 35)
+  x.set_ith_slice([1,4], 36)
+  x.set_ith_slice([0,4], 37)
+  x.set_ith_slice([-1,3], 38)
+  x.set_ith_slice([-1,3], 39)
+  x.set_ith_slice([-1,4], 40)
+  x.set_ith_slice([0,5], 41)
+  x.set_ith_slice([1,6], 42)
+  x.set_ith_slice([0,5], 43)
+  x.set_ith_slice([-1,4], 44)
+  x.set_ith_slice([-1,3], 45)
+  return x
+
+def tube_test_1_01():
+
+  x = SlicedTube(create_tdomain([0.,46.], 0.5, False), Interval())
+  
+  x.set([4,8], [0,1])
+  x.set([2,7], [1,2])
+  x.set([1,6], [2,3])
+  x.set([-4,4], [3,4])
+  x.set([-7,-1], [4,5])
+  x.set([-9,-5], [5,6])
+  x.set([-10,-6], [6,7])
+  x.set([-11,-7], [7,8])
+  x.set([-10,-6], [8,9])
+  x.set([-9,-4], [9,10])
+  x.set([-8,-5], [10,11])
+  x.set([-7,-4], [11,12])
+  x.set([-6,-2], [12,13])
+  x.set([-5,-1], [13,14])
+  x.set([-4,2], [14,15])
+  x.set([-2,4], [15,16])
+  x.set([0,6], [16,17])
+  x.set([2,7], [17,18])
+  x.set([4,8], [18,19])
+  x.set([6,9], [19,20])
+  x.set([7,10], [20,21])
+  x.set([8,11], [21,22])
+  x.set([9,12], [22,23])
+  x.set([8,13], [23,24])
+  x.set([7,12], [24,25])
+  x.set([5,11], [25,26])
+  x.set([3,10], [26,27])
+  x.set([4,9], [27,28])
+  x.set([5,8], [28,29])
+  x.set([4,7], [29,30])
+  x.set([3,6], [30,31])
+  x.set([3,5], [31,32])
+  x.set([2,5], [32,33])
+  x.set([2,5], [33,34])
+  x.set([1,5], [34,35])
+  x.set([2,4], [35,36])
+  x.set([1,4], [36,37])
+  x.set([0,4], [37,38])
+  x.set([-1,3], [38,39])
+  x.set([-1,3], [39,40])
+  x.set([-1,4], [40,41])
+  x.set([0,5], [41,42])
+  x.set([1,6], [42,43])
+  x.set([0,5], [43,44])
+  x.set([-1,4], [44,45])
+  x.set([-1,3], [45,46])
+  return x
+
+def tube_test2():
+
+  x = SlicedTube(create_tdomain([0.,46.], 1., False), Interval())
+  
+  x.set_ith_slice([-2,0], 0)
+  x.set_ith_slice([-3,1], 1)
+  x.set_ith_slice([-1,3], 2)
+  x.set_ith_slice([2,4], 3)
+  x.set_ith_slice([3,5], 4)
+  x.set_ith_slice([2,6], 5)
+  x.set_ith_slice([2,5], 6)
+  x.set_ith_slice([1,4], 7)
+  x.set_ith_slice([1,3], 8)
+  x.set_ith_slice([2,3], 9)
+  x.set_ith_slice([2,4], 10)
+  x.set_ith_slice([1,3], 11)
+  x.set_ith_slice([0,2], 12)
+  x.set_ith_slice([-1,2], 13)
+  x.set_ith_slice([-2,1], 14)
+  x.set_ith_slice([-3,0], 15)
+  x.set_ith_slice([-2,0], 16)
+  x.set_ith_slice([-1,1], 17)
+  x.set_ith_slice([0,2], 18)
+  x.set_ith_slice([1,3], 19)
+  x.set_ith_slice([1,4], 20)
+  x.set_ith_slice([2,5], 21)
+  x.set_ith_slice([2,4], 22)
+  x.set_ith_slice([1,3], 23)
+  x.set_ith_slice([0,2], 24)
+  x.set_ith_slice([0,2], 25)
+  x.set_ith_slice([0,2], 26)
+  x.set_ith_slice([1,2], 27)
+  x.set_ith_slice([1,3], 28)
+  x.set_ith_slice([0,3], 29)
+  x.set_ith_slice([-1,2], 30)
+  x.set_ith_slice([-2,1], 31)
+  x.set_ith_slice([-3,0], 32)
+  x.set_ith_slice([-4,-1], 33)
+  x.set_ith_slice([-4,-2], 34)
+  x.set_ith_slice([-3,-1], 35)
+  x.set_ith_slice([-4,-2], 36)
+  x.set_ith_slice([-4,-2], 37)
+  x.set_ith_slice([-4,-2], 38)
+  x.set_ith_slice([-3,-1], 39)
+  x.set_ith_slice([-3,-1], 40)
+  x.set_ith_slice([-2,-1], 41)
+  x.set_ith_slice([-1,1], 42)
+  x.set_ith_slice([-1,1], 43)
+  x.set_ith_slice([0,2], 44)
+  x.set_ith_slice([1,3], 45)
+  return x
+
+def tube_test3():
+
+  x = SlicedTube(create_tdomain([0.,5.], 1., False), Interval())
+
+  x.set_ith_slice([1,3], 0)
+  x.set_ith_slice([0,2], 1)
+  x.set_ith_slice([-1,1], 2)
+  x.set_ith_slice([-2,0], 3)
+  x.set_ith_slice([-3,-1], 4)
+  return x
+
+def tube_test4():
+
+  x = SlicedTube(create_tdomain([0.,21.], 1., False), Interval())
+
+  x.set([1,2], [0,9])
+  x.set([0.5,1.5], [9,11])
+  x.set([-1,1], [10.2]) # degenerate time interval
+  x.set([-1.5,-0.5], [11,12])
+  x.set([-1,1], [12,13])
+  x.set([0.5,1.5], [13,14])
+  x.set([1,2], [14,21])
+  return x
+
+def tube_test4_05():
+
+  x = SlicedTube(create_tdomain([0.,21.], 0.5, False), Interval())
+
+  x.set([1,2], [0,9])
+  x.set([0.5,1.5], [9,10])
+  x.set([-1,1], [10,11])
+  x.set([-1.5,-0.5], [11,12])
+  x.set([-1,1], [12,13])
+  x.set([0.5,1.5], [13,14])
+  x.set([1,2], [14,21])
+  return x