codac4matlab 2.0.0.dev20__cp39-cp39-win_amd64.whl → 2.0.0.dev25__cp39-cp39-win_amd64.whl

codac4matlab/tests/test_Slice_polygon.py

@@ -0,0 +1,208 @@
+#!/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 *
+import sys
+import math
+
+class TestPolygonSlice(unittest.TestCase):
+
+  def test_polygon_slice_1(self):
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval())
+    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())
+    x.set([-1,2],-1)
+    x.set([-2,0],3)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(-1.,3.))
+    self.assertTrue(p1.box()[1] == Interval(-3.5,3.))
+
+    p2 = ConvexPolygon([ [-1,-1],[-1,2],[0,3],[3,0],[3,-2],[1.5,-3.5] ])
+    self.assertTrue(Approx(p1) == p2)
+
+  def test_polygon_slice_2(self):
+
+    tdomain = create_tdomain([-1,3])
+    x = SlicedTube(tdomain, Interval(-5,3))
+    v = SlicedTube(tdomain, Interval(-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(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(-1.,3.))
+    self.assertTrue(p1.box()[1] == Interval(-5,3.))
+
+    p2 = ConvexPolygon([ [-1,-1],[-1,3],[3,-1],[3,-5],[-1,1] ])
+    self.assertTrue(Approx(p1) == p2)
+
+  def test_polygon_slice_3(self):
+
+    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(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(-1.,3.))
+    self.assertTrue(p1.box()[1] == Interval(-3,1.))
+
+    #DefaultFigure::draw_polygon(p1)
+
+    p2 = ConvexPolygon([ [-1,1],[3,-3] ])
+
+    self.assertTrue(Approx(p1) == p2)
+    self.assertTrue(p1.size() == 1)
+
+  def test_polygon_slice_4(self):
+
+    tdomain = create_tdomain([0,4])
+    x = SlicedTube(tdomain, Interval(-1,7))
+    v = SlicedTube(tdomain, Interval(-1.5,4))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([2,3],0)
+    x.set([3,4],4)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(0,4))
+    self.assertTrue(p1.box()[1] == Interval(-1,7))
+
+    p2 = ConvexPolygon([ [0,2],[0,3],[1,7],[2,7],[4,4],[4,3],[3,-1],[2,-1] ])
+    self.assertTrue(Approx(p1) == p2)
+
+  def test_polygon_slice_4b(self):
+
+    tdomain = create_tdomain([4,8])
+    x = SlicedTube(tdomain, Interval(-1,7))
+    v = SlicedTube(tdomain, Interval(-0.75,-0.5))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([3,4],4)
+    x.set([1],8)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(4,8))
+    self.assertTrue(p1.box()[1] == Interval(1,4))
+
+    #DefaultFigure::draw_polygon(p1)
+
+    p2 = ConvexPolygon([ [4,3],[4,4],[8,1] ])
+    self.assertTrue(Approx(p1,1e-10) == p2)
+
+  def test_polygon_slice_5(self):
+
+    tdomain = create_tdomain([8,12])
+    x = SlicedTube(tdomain, Interval(-1,7))
+    v = SlicedTube(tdomain, Interval(-1./3.,1))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([1],8)
+    x.set([1],12)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(8,12))
+    self.assertTrue(Approx(p1.box()[1]) == Interval(0,2))
+
+    #DefaultFigure::draw_polygon(p1)
+
+    p2 = ConvexPolygon([ [8,1],[9,2],[12,1],[11,0] ])
+    self.assertTrue(Approx(p1,1e-10) == p2)
+
+  def test_polygon_slice_6(self):
+
+    tdomain = create_tdomain([12,14])
+    x = SlicedTube(tdomain, Interval(-1,7))
+    v = SlicedTube(tdomain, Interval(4.5)/2)
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set([1],12)
+    x.set([5.5],14)
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx, sv)
+
+    p1 = sx.polygon_slice(sv)
+    self.assertTrue(p1.box()[0] == Interval(12,14))
+    self.assertTrue(Approx(p1.box()[1]) == Interval(1,5.5))
+
+    #DefaultFigure::draw_polygon(p1)
+
+    p2 = ConvexPolygon([ [12,1],[14,5.5] ])
+    self.assertTrue(Approx(p1,1e-10) == p2)
+
+  def test_polygon_from_tubint_paper(self):
+
+    tdomain = create_tdomain([4,5])
+    x = SlicedTube(tdomain, (Interval(7)/2)|(Interval(17)/4))
+    v = SlicedTube(tdomain, (-Interval(1)/2)|(Interval(1)/2))
+
+    sx = x.first_slice()
+    sv = v.first_slice()
+
+    x.set((Interval(7)/2)|4,4)
+    x.set([4],5)
+
+    p = sx.polygon_slice(sv);
+    self.assertTrue(p == ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]]))
+
+    ctc_deriv = CtcDeriv(TimePropag.FWD_BWD, False)
+    ctc_deriv.contract(sx,sv)
+    p = sx.polygon_slice(sv);
+    self.assertTrue(p == ConvexPolygon([[4,4],[4,3.5],[5,4],[4.5,4.25]]))
+
+    y = Interval(41)/10
+    self.assertTrue(Approx(x.invert(y, v, x.tdomain().t0_tf()),1e-10) == ((Interval(21)/5)|(Interval(24)/5)))
+
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_SlicedTube.py

@@ -12,9 +12,13 @@ from codac import *
 import sys
 import math
 
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '.')))
+import codac2_tests_predefined_tubes as predef
+
 def return_a_tube():
   return SlicedTube(
-    create_tdomain(Interval(0,2),0.5),
+    create_tdomain(Interval(0,2),0.5,False),
     IntervalVector.constant(3,Interval(-1.5,1)))
 
 class TestSlicedTube(unittest.TestCase):
@@ -50,7 +54,7 @@ class TestSlicedTube(unittest.TestCase):
     self.assertTrue(tdomain.tslice(0.01) == Interval(0,1))
     self.assertTrue(tdomain.tslice(1) == Interval(1,2))
     self.assertTrue(tdomain.tslice(2) == Interval(2,3))
-    self.assertTrue(tdomain.tslice(previous_float(3.)) == Interval(2,3))
+    self.assertTrue(tdomain.tslice(prev_float(3.)) == Interval(2,3))
     self.assertTrue(tdomain.tslice(3) == Interval(3,oo))
     self.assertTrue(tdomain.tslice(next_float(3.)) == Interval(3,oo))
 
@@ -184,7 +188,7 @@ class TestSlicedTube(unittest.TestCase):
     self.assertTrue(v[3].codomain() == IntervalVector.constant(3,Interval(-10,10)))
 
     self.assertTrue(x(-42.) == IntervalVector.constant(3,Interval(2.,3.)))
-    self.assertTrue(x(previous_float(-42.)) == IntervalVector(3))
+    self.assertTrue(x(prev_float(-42.)) == IntervalVector(3))
     self.assertTrue(x(next_float(-42.)) == IntervalVector(3))
 
     # Eval: affectation at interval t
@@ -204,12 +208,12 @@ class TestSlicedTube(unittest.TestCase):
     self.assertTrue(v[13].codomain() == IntervalVector.constant(3,Interval(9.,10.)))
 
     self.assertTrue(x(Interval(44,55)) == IntervalVector.constant(3,Interval(9.,10.)))
-    self.assertTrue(x(previous_float(44.)) == IntervalVector(3))
+    self.assertTrue(x(prev_float(44.)) == IntervalVector(3))
     self.assertTrue(x(next_float(55.)) == IntervalVector(3))
 
   def test_sliceT(self):
 
-    tdomain = create_tdomain(Interval(0,1), 0.1)
+    tdomain = create_tdomain(Interval(0,1), 0.1, False)
     x = SlicedTube(tdomain, IntervalVector(2))
     self.assertTrue(x.nb_slices() == 10)
     # C++ like: self.assertTrue(tdomain.tslice(-oo) == tdomain.end())
@@ -300,5 +304,259 @@ class TestSlicedTube(unittest.TestCase):
     self.assertTrue(Approx(tdomain.tslice(2.)) == Interval(1.900000000000001, 2.000000000000002))
     self.assertTrue(Approx(a(Interval(1,2)),1e-4) == Interval(-2.17496, 7.13757))
 
+  def test_specific_detected_bug_from_sampling(self):
+
+    tdomain = create_tdomain([0.,46.], 0.5, False)
+    x = SlicedTube(tdomain, Interval())
+    tdomain.sample(46, False)
+    x.set([-1,3], [30,31])
+    self.assertTrue(x([30,31]) == Interval(-1,3))
+    x.set([-1,3], [45,46])
+    self.assertTrue(x([45,46]) == Interval(-1,3))
+    self.assertTrue(x([45.5,46]) == Interval(-1,3))
+    self.assertTrue(x(45.8) == Interval(-1,3))
+    self.assertTrue(x(45.2) == Interval(-1,3))
+
+  def test_SlicedTube_as_operator_1dcase(self):
+
+    t = ScalarVar()
+    f = AnalyticFunction([t], cos(t))
+    analytic_traj = AnalyticTraj(f, [-PI,PI])
+    sampled_traj = analytic_traj.sampled(1e-2)
+    tdomain = create_tdomain([-PI,PI],1e-2,False)
+    tube = SlicedTube(tdomain, sampled_traj)
+    g = tube.as_function()
+
+    h = AnalyticFunction([t], g(t))
+
+    t_ = -math.pi
+    while t_ < math.pi:
+      self.assertTrue(Approx(h.real_eval(t_),1e-4) == math.cos(t_))
+      t_=t_+1e-2
+
+  def test_SlicedTube_as_operator_ndcase(self):
+
+    t = ScalarVar()
+    f = AnalyticFunction(
+      [t],
+      vec(2*cos(t),sin(2*t))
+    )
+
+    analytic_traj = AnalyticTraj(f, [0,5])
+    sampled_traj = analytic_traj.sampled(1e-2)
+    tdomain = create_tdomain([0,5],1e-3,False)
+    tube = SlicedTube(tdomain, sampled_traj)
+    g = tube.as_function()
+
+    h = AnalyticFunction(
+      [t],
+      g(t)
+    )
+
+    t_ = 0
+    while t_ < 5:
+      self.assertTrue(Approx(h.eval(t_),1e-2) == IntervalVector([2*math.cos(t_),math.sin(2*t_)]))
+      t_=t_+1e-2
+
+    h = AnalyticFunction(
+      [t],
+      [ g(t)[0],g(t)[1] ]
+    )
+
+    t_ = 0
+    while t_ < 5:
+      self.assertTrue(Approx(h.eval(t_),1e-2) == IntervalVector([2*math.cos(t_),math.sin(2*t_)]))
+      t_=t_+1e-2
+
+
+  def test_inversion_scalar_tube(self):
+
+    x = predef.tube_test_1()
+    x.set_ith_slice(Interval(-4,2), 14) # to test primitives pre-computation
+
+    self.assertTrue(x.invert([0], x.tdomain().t0_tf()) == Interval(3,46))
+    self.assertTrue(x.invert([-7], x.tdomain().t0_tf()) == Interval(4,12))
+    self.assertTrue(x.invert(Interval(), x.tdomain().t0_tf()) == Interval(0,46))
+    self.assertTrue(x.invert([-12,14], x.tdomain().t0_tf()) == Interval(0,46))
+    self.assertTrue(x.invert([-20,-18], x.tdomain().t0_tf()) == Interval.empty())
+    self.assertTrue(x.invert([-1,1], x.tdomain().t0_tf()) == Interval(2,46))
+    self.assertTrue(x.invert([-10.5], x.tdomain().t0_tf()) == Interval(7,8))
+    self.assertTrue(x.invert([-12,-7], x.tdomain().t0_tf()) == Interval(4,12))
+    self.assertTrue(x.invert([10,11], x.tdomain().t0_tf()) == Interval(20,27))
+    self.assertTrue(x.invert([6.01,7], x.tdomain().t0_tf()) == Interval(0,30))
+    self.assertTrue(x.invert([6,7], x.tdomain().t0_tf()) == Interval(0,43))
+    self.assertTrue(x.invert([5.9,7], x.tdomain().t0_tf()) == Interval(0,43))
+
+  
+  def test_inversion_scalar_tube_subsets(self):
+
+    x = predef.tube_test_1()
+    x.set_ith_slice(Interval(-4,2), 14) # to test primitives pre-computation
+
+    v = []
+
+    x.invert(Interval(0), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 4)
+
+    if len(v) == 4:
+      self.assertTrue(v[0] == Interval(3,4))
+      self.assertTrue(v[1] == Interval(14,17))
+      self.assertTrue(v[2] == Interval(37,42))
+      self.assertTrue(v[3] == Interval(43,46))
+
+    # The same, with a custom domain:
+    x.invert(Interval(0), v, Interval(3.8,42.5))
+    self.assertTrue(len(v) == 3)
+
+    if len(v) == 3:
+      self.assertTrue(v[0] == Interval(3.8,4))
+      self.assertTrue(v[1] == Interval(14,17))
+      self.assertTrue(v[2] == Interval(37,42))
+
+    x.invert(Interval(-1,1), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 4)
+
+    if len(v) == 4:
+      self.assertTrue(v[0] == Interval(2,5))
+      self.assertTrue(v[1] == Interval(13,17))
+      self.assertTrue(v[2] == Interval(34,35))
+      self.assertTrue(v[3] == Interval(36,46))
+
+    # The same, with a custom domain (empty):
+    x.invert(Interval(-1,1), v, Interval.empty())
+    self.assertTrue(len(v) == 0)
+
+    x.invert(Interval(-6.9999), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 2)
+
+    if len(v) == 2:
+      self.assertTrue(v[0] == Interval(4,7))
+      self.assertTrue(v[1] == Interval(8,12))
+
+    x.invert(Interval(), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 1)
+
+    if len(v) == 1:
+      self.assertTrue(v[0] == Interval(0,46))
+
+    x.invert(Interval(-30,-29), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 0)
+
+    x.invert(Interval(3.5), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 5)
+
+    if len(v) == 5:
+      self.assertTrue(v[0] == Interval(1,4))
+      self.assertTrue(v[1] == Interval(15,18))
+      self.assertTrue(v[2] == Interval(26,27))
+      self.assertTrue(v[3] == Interval(30,38))
+      self.assertTrue(v[4] == Interval(40,45))
+
+    x.invert(Interval(9.5,30), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 1)
+
+    if len(v) == 1:
+      self.assertTrue(v[0] == Interval(20,27))
+
+    x.invert(Interval(12,13), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 1)
+
+    if len(v) == 1:
+      self.assertTrue(v[0] == Interval(22,25))
+
+    x.invert(Interval(-4,-3), v, x.tdomain().t0_tf())
+    self.assertTrue(len(v) == 3)
+
+    if len(v) == 3:
+      self.assertTrue(v[0] == Interval(3,5))
+      self.assertTrue(v[1] == Interval(9,10))
+      self.assertTrue(v[2] == Interval(11,15))
+
+
+  def test_inversion_derivative(self):
+
+    tdomain = create_tdomain([0,5],1.)
+    x = SlicedTube(tdomain, Interval())
+    v = SlicedTube(tdomain, Interval())
+
+    x.set([0], 0)
+    x.set([4], 5)
+
+    v.set_ith_slice([1,2], 0*2+1)
+    v.set_ith_slice((Interval(1)/2) | (Interval(3)/2), 1*2+1)
+    v.set_ith_slice(Interval(0) | (Interval(1)/2), 2*2+1)
+    v.set_ith_slice([0], 3*2+1)
+    v.set_ith_slice((Interval(-1)/2) | (Interval(1)/2), 4*2+1)
+
+    ctc = CtcDeriv(TimePropag.FWD_BWD)
+    ctc.contract(x, v)
+    ctc.contract(x, v)
+    ctc.contract(x, v)
+
+    self.assertTrue(x.invert(x.codomain(), x.tdomain().t0_tf()) == x.tdomain().t0_tf())
+    self.assertTrue(x.invert(Interval(), x.tdomain().t0_tf()) == x.tdomain().t0_tf())
+
+    # Using derivative
+    self.assertTrue(x.invert(x.codomain(), v, x.tdomain().t0_tf()) == x.tdomain().t0_tf())
+    self.assertTrue(x.invert(Interval(), v, x.tdomain().t0_tf()) == x.tdomain().t0_tf())
+    self.assertTrue(x.invert(Interval(0.), v, x.tdomain().t0_tf()) == Interval(0))
+    self.assertTrue(Approx(x.slice(tdomain.tslice(4.5)).invert(Interval(4.25), v.slice(tdomain.tslice(4.5)), tdomain.tslice(4.5)),1e-10) == Interval(9)/2)
+    self.assertTrue(x.invert(Interval(17)/4, v, x.tdomain().t0_tf()) == Interval(Interval(9)/2))
+    self.assertTrue(Approx(x.invert(Interval(4), v, x.tdomain().t0_tf()),1e-10) == Interval(3,5))
+
+    self.assertTrue(Approx(x.slice(tdomain.tslice(4.5)).invert(Interval(41)/10, v.slice(tdomain.tslice(4.5)), tdomain.tslice(4.5)),1e-10) == ((Interval(21)/5)|(Interval(24)/5)))
+
+    self.assertTrue(Approx(x.invert(Interval(41)/10, v, x.tdomain().t0_tf()),1e-10) == ((Interval(21)/5)|(Interval(24)/5)))
+    self.assertTrue(x.invert((Interval(7)/2), v, x.tdomain().t0_tf()) == Interval(2,4))
+    self.assertTrue(x.invert(Interval.empty(), v, x.tdomain().t0_tf()) == Interval.empty())
+    self.assertTrue(x.invert(Interval(10), v, x.tdomain().t0_tf()) == Interval.empty())
+    self.assertTrue(x.invert(Interval(2,3), v, x.tdomain().t0_tf()) == Interval(1,2))
+    self.assertTrue(x.invert(Interval(1), v, x.tdomain().t0_tf()) == Interval(0.5,0.75))
+    self.assertTrue(x.invert((Interval(7)/2) | Interval(4), v, x.tdomain().t0_tf()) == Interval(2,5))
+  
+
+  def test_inversion_another_test(self):
+
+    tdomain = create_tdomain([-20,20],0.05)
+    t = ScalarVar()
+    f = AnalyticFunction([t], Interval(-1,1)*((t^2)+1))
+    x = SlicedTube(tdomain, f)
+    self.assertTrue(x.invert(0., x.tdomain().t0_tf()) == x.tdomain().t0_tf())
+
+
+  def test_inversion_vector_tube(self):
+
+    x0 = predef.tube_test_1()
+    x = SlicedTube(x0.tdomain(), IntervalVector(2))
+
+    for xi, x0i in zip(x, x0):
+      xi.set(cart_prod(x0i.codomain(), x0i.codomain() - 3), False)
+
+    inv_val = IntervalVector.constant(2,[0.5,0.5])
+    v_t = []
+    x.invert(inv_val, v_t, x.tdomain().t0_tf())
+
+    self.assertTrue(len(v_t) == 5)
+    self.assertTrue(v_t[0] == Interval(3,4))
+    self.assertTrue(v_t[1] == Interval(15,17))
+    self.assertTrue(v_t[2] == Interval(37,38))
+    self.assertTrue(v_t[3] == Interval(40,42))
+    self.assertTrue(v_t[4] == Interval(43,45))
+
+    # Union inversion:
+    inv = x.invert(inv_val, x.tdomain().t0_tf())
+    self.assertTrue(inv == Interval(3,45))
+
+    # Restricted domain
+    restricted = Interval(15.2,39)
+    x.invert(inv_val, v_t, restricted)
+    self.assertTrue(len(v_t) == 2)
+    self.assertTrue(v_t[0] == Interval(15.2,17))
+    self.assertTrue(v_t[1] == Interval(37,38))
+
+    inv = x.invert(inv_val, restricted)
+    self.assertTrue(inv == Interval(15.2,38))
+
+
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_cart_prod.py

@@ -32,6 +32,7 @@ class TestIntervalVector(unittest.TestCase):
     self.assertTrue(cart_prod(IntervalVector.empty(3)) == IntervalVector.empty(3))
     self.assertTrue(cart_prod([[0,1],[2,3],[4,5]],[[8,9]]) == IntervalVector([[0,1],[2,3],[4,5],[8,9]]))
     self.assertTrue(cart_prod(25.,[[0,1],[2,3],[4,5]],[[8,9]],Vector.ones(3)) == IntervalVector([[25],[0,1],[2,3],[4,5],[8,9],[1],[1],[1]]))
+    self.assertTrue(cart_prod([-oo,oo],[-oo,oo],42.) == IntervalVector([[-oo,oo],[-oo,oo],[42.,42.]]))
 
 if __name__ ==  '__main__':
   unittest.main()

codac4matlab/tests/test_peibos.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+
+#  Codac tests
+# ----------------------------------------------------------------------------
+#  \date       2025
+#  \author     Maël Godard
+#  \copyright  Copyright 2024 Codac Team
+#  \license    GNU Lesser General Public License (LGPL)
+
+import unittest
+from codac import *
+import sys
+import math
+
+class TestPeibos(unittest.TestCase):
+
+  def test_peibos(self):
+
+    # 2D checks of the PEIBOS algorithm
+
+    y_2d = VectorVar(2)
+    f_2d = AnalyticFunction([y_2d],[sqr(y_2d[0])-sqr(y_2d[1])+y_2d[0],2.*y_2d[0]*y_2d[1] + y_2d[1]])
+
+    X_2d = VectorVar(1)
+    psi0_2d = AnalyticFunction([X_2d],[cos(X_2d[0]*PI/4.),sin(X_2d[0]*PI/4.)])
+
+    id_2d = OctaSym([1, 2])
+    s = OctaSym([-2, 1])
+
+    v_par_2d = PEIBOS(f_2d,psi0_2d,[id_2d,s,s*s,s.invert()],0.25,[-0.2,0.])
+
+    b0 = Vector([-0.5,0.0])
+    b1 = Vector([0.0,1.45])
+    b2 = Vector([-1.165,0.0])
+
+    count_b0, count_b1, count_b2 = 0, 0, 0
+
+    for p in v_par_2d:
+      if (p.contains(b0))==BoolInterval.TRUE:
+        count_b0 += 1
+      if (p.contains(b1))==BoolInterval.TRUE:
+        count_b1 += 1
+      if (p.contains(b2))==BoolInterval.TRUE:
+        count_b2 += 1
+
+    self.assertTrue(count_b0 == 0)
+    self.assertTrue(count_b1 == 1)
+    self.assertTrue(count_b2 == 2)
+
+    # 3D checks of the PEIBOS algorithm
+
+    y_3d = VectorVar(3)
+    f_3d = AnalyticFunction([y_3d],[y_3d[0],y_3d[1],y_3d[2]])
+
+    X_3d = VectorVar(2)
+    psi0_3d = AnalyticFunction([X_3d],[1/sqrt(1+sqr(X_3d[0])+sqr(X_3d[1])),X_3d[0]/sqrt(1+sqr(X_3d[0])+sqr(X_3d[1])),X_3d[1]/sqrt(1+sqr(X_3d[0])+sqr(X_3d[1]))])
+
+    id_3d = OctaSym([1, 2, 3])
+    s1 = OctaSym([-2, 1, 3])
+    s2 = OctaSym([3, 2, -1])
+
+    v_par_3d = PEIBOS(f_3d,psi0_3d,[id_3d,s1,s1*s1,s1.invert(),s2,s2.invert()],2.0)
+
+    self.assertTrue(len(v_par_3d) == 6)
+
+    self.assertTrue(Approx(v_par_3d[0].z,1e-6) == Vector([1.,0.,0.]))
+    self.assertTrue(Approx(v_par_3d[1].z,1e-6) == Vector([0.,1.,0.]))
+    self.assertTrue(Approx(v_par_3d[2].z,1e-6) == Vector([-1,0.,0.]))
+    self.assertTrue(Approx(v_par_3d[3].z,1e-6) == Vector([0.,-1.,0.]))
+    self.assertTrue(Approx(v_par_3d[4].z,1e-6) == Vector([0.,0.,-1.]))
+    self.assertTrue(Approx(v_par_3d[5].z,1e-6) == Vector([0.,0.,1.]))
+
+    a = 4.35066
+
+    self.assertTrue(Approx(v_par_3d[0].A,1e-5) == Matrix([[0.,0.,a],[a+1,0.,0.],[0.,a+1,0.]]))
+    self.assertTrue(Approx(v_par_3d[1].A,1e-5) == Matrix([[-(a+1),0.,0.],[0.,0.,a],[0.,a+1,0.]]))
+    self.assertTrue(Approx(v_par_3d[2].A,1e-5) == Matrix([[0.,0.,a],[-(a+1),0.,0.],[0.,a+1,0.]]))
+    self.assertTrue(Approx(v_par_3d[3].A,1e-5) == Matrix([[a+1,0.,0.],[0.,0.,a],[0.,a+1,0.]]))
+    self.assertTrue(Approx(v_par_3d[4].A,1e-5) == Matrix([[0.,a+1,0.],[a+1,0.,0.],[0.,0.,a]]))
+    self.assertTrue(Approx(v_par_3d[5].A,1e-5) == Matrix([[0.,-(a+1),0.],[a+1,0.,0.],[0.,0.,a]]))
+      
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_predefined_tubes.py

@@ -2,7 +2,7 @@ from codac import *
 
 def tube_test_1():
 
-  x = SlicedTube(create_tdomain([0.,46.], 1.), Interval())
+  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)
@@ -53,7 +53,7 @@ def tube_test_1():
 
 def tube_test_1_01():
 
-  x = SlicedTube(create_tdomain([0.,46.], 0.5), Interval())
+  x = SlicedTube(create_tdomain([0.,46.], 0.5, False), Interval())
   
   x.set([4,8], [0,1])
   x.set([2,7], [1,2])
@@ -105,7 +105,7 @@ def tube_test_1_01():
 
 def tube_test2():
 
-  x = SlicedTube(create_tdomain([0.,46.], 1.), Interval())
+  x = SlicedTube(create_tdomain([0.,46.], 1., False), Interval())
   
   x.set_ith_slice([-2,0], 0)
   x.set_ith_slice([-3,1], 1)
@@ -157,7 +157,7 @@ def tube_test2():
 
 def tube_test3():
 
-  x = SlicedTube(create_tdomain([0.,5.], 1.), Interval())
+  x = SlicedTube(create_tdomain([0.,5.], 1., False), Interval())
 
   x.set_ith_slice([1,3], 0)
   x.set_ith_slice([0,2], 1)
@@ -168,7 +168,7 @@ def tube_test3():
 
 def tube_test4():
 
-  x = SlicedTube(create_tdomain([0.,21.], 1.), Interval())
+  x = SlicedTube(create_tdomain([0.,21.], 1., False), Interval())
 
   x.set([1,2], [0,9])
   x.set([0.5,1.5], [9,11])
@@ -181,7 +181,7 @@ def tube_test4():
 
 def tube_test4_05():
 
-  x = SlicedTube(create_tdomain([0.,21.], 0.5), Interval())
+  x = SlicedTube(create_tdomain([0.,21.], 0.5, False), Interval())
 
   x.set([1,2], [0,9])
   x.set([0.5,1.5], [9,10])