codac4matlab 2.0.0.dev25__cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

codac4matlab/tests/test_Interval_operations.py

@@ -0,0 +1,293 @@
+#!/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
+
+MAX_DOUBLE = sys.float_info.max
+
+class TestInterval_operations(unittest.TestCase):
+
+  def CHECK_add(self, x, y, expected):
+    self.assertTrue((x + y) == expected)
+    self.assertTrue((y + x) == expected) # symmetrical case
+    x_ = Interval(x); x_ += y
+    self.assertTrue(x_ == expected) # +=operator
+    y_ = Interval(y); y_ += x
+    self.assertTrue(y_ == expected) # +=operator in the other direction
+    self.assertTrue(((-x)-y) == -expected) # substraction
+    self.assertTrue(((-y)-x) == -expected) # symmetrical case
+    x_ = Interval(-x); x_ -= y
+    self.assertTrue(x_ == -expected) # -=operator
+    y_ = Interval(-y); y_ -= x
+    self.assertTrue(y_ == -expected) # -=operator in the other direction
+
+  def CHECK_add_scalar(self, x, y, expected):
+    self.assertTrue((x+y) == expected)
+    self.assertTrue((y+x) == expected)
+    x_ = Interval(x); x_ += y
+    self.assertTrue(x_ == expected) # test the +=operator
+    self.assertTrue(((-x)-y) == -expected)
+    self.assertTrue(((-y)-x) == -expected)
+    x_ = Interval(-x); x_ -= y
+    self.assertTrue(x_ == -expected) # test the -=operator
+
+  def CHECK_mul(self, x, y, expected):
+    self.assertTrue(x * y == expected)
+    self.assertTrue(y * x == expected) # symmetrical case
+    x_ = Interval(x); x_ *= y
+    self.assertTrue(x_ == expected) # *=operator
+
+  def CHECK_mul_scalar(self, x, y, expected):
+    self.assertTrue(x * y == expected)
+    self.assertTrue(y * x == expected) # symmetrical case
+    x_ = Interval(x); x_ *= y
+    self.assertTrue(x_ == expected) # *=operator
+
+  def CHECK_div(self, x, y, expected):
+    self.assertTrue(x / Interval(y) == expected)
+    self.assertTrue(Interval(x) / y == expected)
+    x_ = Interval(x); x_ /= y
+    self.assertTrue(x_ == expected) # /=operator
+
+  def CHECK_div_scalar(self, x, y, expected):
+    self.assertTrue(x / y == expected)
+    x_ = Interval(x); x_ /= y
+    self.assertTrue(x_ == expected) # /=operator
+
+  def CHECK_trigo(self, x, expected):
+    self.assertTrue(Approx(sin(x), 1e-9) == expected)
+    self.assertTrue(Approx(sin(Interval.pi()-x), 1e-9) == expected)
+    self.assertTrue(Approx(sin(x+Interval.two_pi()), 1e-9) == expected)
+    self.assertTrue(Approx(sin(-x), 1e-9) == -expected)
+    self.assertTrue(Approx(cos(x-Interval.half_pi()), 1e-9) == expected)
+    self.assertTrue(Approx(cos(Interval.half_pi()-x), 1e-9) == expected)
+    self.assertTrue(Approx(cos(x+Interval.half_pi()), 1e-9) == -expected)
+    self.assertTrue(Approx(cos(x+Interval.two_pi()-Interval.half_pi()), 1e-9) == expected)
+
+  def CHECK_pow(self, x, p, expected, eps = 0.):
+    self.assertTrue(Approx(pow(x,p),eps) == expected)
+    if p%2==0:
+      self.assertTrue(Approx(pow(-x,p),eps) == expected)
+    else:
+      self.assertTrue(Approx(pow(-x,p),eps) == -expected)
+
+  def test_interval_operations(self):
+
+    self.assertTrue(0 < next_float(0))
+    self.assertTrue(0 > prev_float(0))
+    self.assertTrue(1 < next_float(1))
+    self.assertTrue(1 > prev_float(1))
+    self.assertTrue(oo == next_float(oo))
+    self.assertTrue(-oo == prev_float(-oo))
+    self.assertTrue(-MAX_DOUBLE >= next_float(-oo))
+    self.assertTrue(MAX_DOUBLE <= prev_float(oo))
+    self.assertTrue(oo > MAX_DOUBLE)
+    self.assertTrue(-oo < -MAX_DOUBLE)
+    self.assertTrue(-Interval(0,1) == Interval(-1,0))
+    self.assertTrue(-Interval(-oo,oo) == Interval(-oo,oo))
+    self.assertTrue(-Interval(-oo,0) == Interval(0,oo))
+    self.assertTrue(-Interval(-oo,1) == Interval(-1,oo))
+
+    self.CHECK_add(Interval.empty(), Interval(0,1), Interval.empty())
+    self.CHECK_add(Interval(0,1), Interval.empty(), Interval.empty())
+    self.CHECK_add(Interval(-oo,1), Interval(0,1), Interval(-oo, 2))
+    self.CHECK_add(Interval(1,oo), Interval(0,1), Interval(1,oo))
+    self.CHECK_add(Interval(-oo,oo), Interval(0,1), Interval(-oo,oo))
+    self.CHECK_add(Interval(MAX_DOUBLE,oo), 1, Interval(MAX_DOUBLE,oo))
+    self.CHECK_add(Interval(MAX_DOUBLE,oo), -1, Interval(prev_float(MAX_DOUBLE),oo))
+    self.CHECK_add(Interval(MAX_DOUBLE,oo), Interval(MAX_DOUBLE,oo), Interval(MAX_DOUBLE,oo))
+    self.CHECK_add(Interval(MAX_DOUBLE,oo), -oo, Interval.empty())
+    self.CHECK_add(Interval(MAX_DOUBLE,oo), oo, Interval.empty())
+    self.CHECK_add(Interval(-oo,-MAX_DOUBLE), 1, Interval(-oo,next_float(-MAX_DOUBLE)))
+    self.CHECK_add(Interval(-oo,-MAX_DOUBLE), -1, Interval(-oo,-MAX_DOUBLE))
+    self.CHECK_add(Interval(-oo,-MAX_DOUBLE), Interval(-oo,-MAX_DOUBLE), Interval(-oo,-MAX_DOUBLE))
+
+    self.CHECK_add_scalar(Interval.empty(), oo, Interval.empty())
+    self.CHECK_add_scalar(Interval.empty(), 0, Interval.empty())
+    self.CHECK_add_scalar(Interval(0,1), 1, Interval(1,2))
+    self.CHECK_add_scalar(Interval(0,1), -oo, Interval.empty())
+    self.CHECK_add_scalar(Interval(0,1), oo, Interval.empty())
+    self.CHECK_add_scalar(Interval(-oo,1), 1, Interval(-oo,2))
+
+    self.CHECK_mul(Interval.empty(), Interval(0,1), Interval.empty())
+    self.CHECK_mul(0, Interval(-oo,oo), 0)
+    self.CHECK_mul(Interval(-1,1), Interval(-oo,0), Interval(-oo,oo))
+    self.CHECK_mul(Interval(-oo,-1), Interval(-1,0), Interval(0,oo))
+    self.CHECK_mul(Interval(-oo, 1), Interval(-1,0), Interval(-1,oo))
+    self.CHECK_mul(Interval(0, 1), Interval(1,oo), Interval(0,oo))
+    self.CHECK_mul(Interval(0, 1), Interval(-1,oo), Interval(-1,oo))
+    self.CHECK_mul(Interval(-oo,-1), Interval(0,1), Interval(-oo,0))
+    self.CHECK_mul(Interval(-oo, 1), Interval(0,1), Interval(-oo,1))
+    self.CHECK_mul(Interval(0, 1), Interval(-oo,-1), Interval(-oo,0))
+    self.CHECK_mul(Interval(0, 1), Interval(-oo,1), Interval(-oo,1))
+    self.CHECK_mul(Interval(1,oo), Interval(0,1), Interval(0,oo))
+    self.CHECK_mul(Interval(-1,oo), Interval(0,1), Interval(-1,oo))
+    self.CHECK_mul(Interval(1,2), Interval(1,2), Interval(1,4))
+    self.CHECK_mul(Interval(1,2), Interval(-2,3), Interval(-4,6))
+    self.CHECK_mul(Interval(-1,1), Interval(-2,3), Interval(-3,3))
+    self.CHECK_mul_scalar(Interval(1,2), -oo, Interval.empty())
+    self.CHECK_mul_scalar(Interval(1,2), oo, Interval.empty())
+    self.CHECK_mul_scalar(Interval(1,2), -1, Interval(-2,-1))
+
+    self.CHECK_div(Interval.empty(), Interval(0,1), Interval.empty())
+    self.CHECK_div(0, 0, Interval.empty())
+    self.CHECK_div(Interval(1,2), 0, Interval.empty())
+    self.CHECK_div(Interval(-oo,oo), 0, Interval.empty())
+    self.CHECK_div(0, Interval(0,1), 0)
+    self.CHECK_div(0, Interval(-oo,oo), 0)
+    self.CHECK_div(Interval(6,12), Interval(2,3), Interval(2,6))
+    self.CHECK_div(Interval(6,12), Interval(-3,-2), Interval(-6,-2))
+    self.CHECK_div(Interval(6,12), Interval(-2,3), Interval(-oo,oo))
+    self.CHECK_div(Interval(-oo,-1), Interval(-1,0), Interval(1,oo))
+    self.CHECK_div(Interval(-oo,-1), Interval(0,1), Interval(-oo,-1))
+    self.CHECK_div(Interval(1,oo), Interval(-1,0), Interval(-oo,-1))
+    self.CHECK_div(Interval(1,oo), Interval(0,1), Interval(1,oo))
+    self.CHECK_div(Interval(-1,1), Interval(-1,1), Interval(-oo,oo))
+    self.CHECK_div_scalar(Interval(1,2), -oo, Interval.empty())
+    self.CHECK_div_scalar(Interval(1,2), oo, Interval.empty())
+    self.CHECK_div_scalar(Interval(1,2), -1, Interval(-2,-1))
+
+    self.assertTrue(sqrt(Interval(-oo,oo)) == Interval(0,oo))
+    self.assertTrue(sqrt(Interval(-oo,0)) == 0)
+    self.assertTrue(sqrt(Interval(-9,4)) == Interval(0,2))
+    self.assertTrue(sqrt(Interval(4,9)) == Interval(2,3))
+    self.assertTrue(sqrt(Interval(-9,-4)) == Interval.empty())
+    self.assertTrue(sqrt(Interval(-9,oo)) == Interval(0,oo))
+
+    self.assertTrue(log(Interval.empty()) == Interval.empty())
+    self.assertTrue(log(Interval(-oo,oo)) == Interval(-oo,oo))
+    self.assertTrue(log(Interval(0,oo)) == Interval(-oo,oo))
+    self.assertTrue(log(Interval(-oo,0)) ==  Interval.empty())
+    self.assertTrue(Approx(log(Interval(1,2))) == Interval(0,math.log(2)))
+    self.assertTrue(Approx(log(Interval(-1,1))) == Interval(-oo,0))
+    self.assertTrue(Approx(log(Interval(0,1))) == Interval(-oo,0))
+    self.assertTrue(Approx(log(Interval(1,oo))) == Interval(0,oo))
+    self.assertTrue(log(Interval(0)) == Interval.empty())
+    self.assertTrue(log(Interval(-2,-1)) == Interval.empty())
+    self.assertTrue((log(Interval(0,next_float(0)))).ub() > -744.5)
+
+    self.assertTrue(exp(Interval.empty()) == Interval.empty())
+    self.assertTrue(exp(Interval(-oo,oo)) == Interval(0,oo))
+    self.assertTrue(Approx(exp(Interval(0,oo))) == Interval(1,oo))
+    self.assertTrue(Approx(exp(Interval(-oo,0))) == Interval(0,1))
+    self.assertTrue(Approx(exp(Interval(0,2))) == Interval(1,math.exp(2)))
+    self.assertTrue(Approx(exp(Interval(-1,1))) == Interval(math.exp(-1),math.exp(1)))
+    self.assertTrue(exp(Interval(1.e100,1.e111)) == Interval(MAX_DOUBLE,oo))
+    self.assertTrue(exp(Interval(MAX_DOUBLE,oo)) == Interval(MAX_DOUBLE,oo))
+    self.assertTrue(Approx(exp(Interval(0,MAX_DOUBLE))) == Interval(1,oo))
+
+    pi_lb = Interval.pi().lb()
+    pi_ub = Interval.pi().ub()
+
+    self.CHECK_trigo(Interval(-oo,oo), Interval(-1,1))
+    self.CHECK_trigo(Interval.empty(), Interval.empty())
+    self.CHECK_trigo(Interval(0,pi_ub/2.0), Interval(0,1))
+    self.CHECK_trigo(Interval(0,pi_ub), Interval(0,1))
+    self.CHECK_trigo(Interval(0,3*pi_ub/2.0), Interval(-1,1))
+    self.CHECK_trigo(Interval(pi_lb,3*pi_ub/2.0), Interval(-1,0))
+    self.CHECK_trigo(Interval(0.5,1.5), Interval(math.sin(0.5),math.sin(1.5)))
+    self.CHECK_trigo(Interval(1.5,3), Interval(math.sin(3.0),1))
+    self.CHECK_trigo(Interval(3,4), Interval(math.sin(4.0),math.sin(3.0)))
+    self.CHECK_trigo(Interval(3,5), Interval(-1,math.sin(3.0)))
+    self.CHECK_trigo(Interval(3,2*pi_ub+1.5), Interval(-1,math.sin(1.5)))
+    self.CHECK_trigo(Interval(5,2*pi_ub+1.5), Interval(math.sin(5.0),math.sin(1.5)))
+    self.CHECK_trigo(Interval(5,2*pi_ub+3), Interval(math.sin(5.0),1))
+
+    self.assertTrue(floor(Interval.empty()) == Interval.empty())
+    self.assertTrue(floor(Interval(-oo,-0.000001)) == Interval(-oo,-1))
+    self.assertTrue(floor(Interval(0.00000001,oo)) == Interval(0,oo))
+    self.assertTrue(floor(Interval(-oo,oo)) == Interval(-oo,oo))
+    self.assertTrue(floor(Interval(0.01,2.99)) == Interval(0,2))
+    self.assertTrue(floor(Interval(-0.01,2.99)) == Interval(-1,2))
+    self.assertTrue(floor(Interval(1.000000001,1.9999999999)) == 1.)
+    self.assertTrue(floor(Interval(1e8, MAX_DOUBLE)) == Interval(1e8,MAX_DOUBLE))
+
+    self.assertTrue(ceil(Interval.empty()) == Interval.empty())
+    self.assertTrue(ceil(Interval(-oo,-0.000001)) == Interval(-oo,0))
+    self.assertTrue(ceil(Interval(0.00000001,oo)) == Interval(1.0,oo))
+    self.assertTrue(ceil(Interval(-oo,oo)) == Interval(-oo,oo))
+    self.assertTrue(ceil(Interval(0.01,2.99)) == Interval(1,3))
+    self.assertTrue(ceil(Interval(-0.01,2.99)) == Interval(0,3))
+    self.assertTrue(ceil(Interval(1.000000001,1.9999999999)) == Interval(2,2))
+    self.assertTrue(ceil(Interval(1e8, MAX_DOUBLE)) == Interval(1e8,MAX_DOUBLE))
+
+    self.assertTrue(integer(Interval.empty()) == Interval.empty())
+    self.assertTrue(integer(Interval(-oo,-0.000001)) == Interval(-oo,-1))
+    self.assertTrue(integer(Interval(0.00000001,oo)) == Interval(1.0,oo))
+    self.assertTrue(integer(Interval(-oo,oo)) == Interval(-oo,oo))
+    self.assertTrue(integer(Interval(0.01,2.99)) == Interval(1,2))
+    self.assertTrue(integer(Interval(-0.01,2.99)) == Interval(0,2))
+    self.assertTrue(integer(Interval(1.000000001,1.9999999999)) == Interval.empty())
+    self.assertTrue(integer(Interval(1e8, MAX_DOUBLE)) == Interval(1e8,MAX_DOUBLE))
+
+    self.assertTrue(tan(Interval.pi()/2.0) == Interval(-oo,oo))
+    x = tan(-Interval.pi())
+    self.assertTrue(x.diam() < 1e-8)
+    self.assertTrue(x.contains(0.))
+
+    self.assertTrue(Approx(tan((3*Interval.pi()/4.0)|(5*Interval.pi()/4.0))) == Interval(-1,1))
+    self.assertTrue(tan(Interval(-oo,oo)) == Interval(-oo,oo))
+    self.assertTrue(Approx(tan((-Interval.pi()/4.0)|(Interval.pi()/4.0))) == Interval(-1,1))
+
+    # tan(pi/4,pi/2)=[1,+oo)
+    x = Interval(pi_lb/4.0,(1-1e-10)*pi_lb/2.0)
+    y = tan(x)
+    self.assertTrue(Approx(Interval(y.lb())) == Interval(1.0))
+    self.assertTrue(y.ub() > 1000)
+
+    # tan(-pi/2,pi/4)=(-oo,1]
+    y = tan(Interval(-(1-1e-10)*pi_lb/2.0,pi_lb/4.0))
+    self.assertTrue(y.lb() < -1000)
+    self.assertTrue(y.ub() == 1.0)
+
+    self.assertTrue(atan2(Interval(-oo,oo),Interval.empty()) == Interval.empty())
+    self.assertTrue(Approx(atan2(Interval(1),1)) == Interval.pi()/4.0)
+    self.assertTrue(Approx(atan2(Interval(-1),-1)) == -3*Interval.pi()/4.0)
+    self.assertTrue(Approx(atan2(Interval(-1),1)) == -Interval.pi()/4.0)
+    self.assertTrue(Approx(atan2(Interval(1),-1)) == 3*Interval.pi()/4.0)
+    self.assertTrue(Approx(atan2(Interval(0,oo),Interval(0,oo))) == Interval(0,1)*Interval.half_pi())
+    self.assertTrue(Approx(atan2(Interval(-oo,prev_float(0.0)),Interval(-oo,0))) == -(Interval.half_pi() | Interval.pi()))
+    self.assertTrue(Approx(atan2(Interval(-oo,0),Interval(0,oo))) == Interval(-1,0)*Interval.half_pi())
+    self.assertTrue(Approx(atan2(Interval(0,oo),Interval(-oo,0))) == (Interval.half_pi() | Interval.pi()))
+    self.assertTrue(Approx(atan2(Interval(1,oo),Interval(-1,1))) == (Interval.pi()/4.0 | 3*Interval.pi()/4.0))
+    self.assertTrue(Approx(atan2(Interval(-oo,-1),Interval(-1,1))) == -(Interval.pi()/4.0 | 3*Interval.pi()/4.0))
+    self.assertTrue(atan2(Interval(-1,1),Interval(1,oo)) == Interval(-1,1)*Interval.pi()/4.0)
+    self.assertTrue(atan2(Interval(-1,1),Interval(-oo,-1)) == Interval(-1,1)*Interval.pi())
+    self.assertTrue(atan2(Interval(-oo,oo),Interval(-oo,oo)) == Interval(-1,1)*Interval.pi())
+    self.assertTrue(atan2(Interval(0),0) == Interval.empty())
+
+    self.CHECK_pow(Interval(-oo,oo), 4, Interval(0,oo))
+    self.CHECK_pow(Interval.empty(), 4, Interval.empty())
+    self.CHECK_pow(Interval(2,3), 4, Interval(16,81))
+    self.CHECK_pow(Interval(-2,3), 4, Interval(0,81))
+    self.CHECK_pow(Interval(-3,2), 4, Interval(0,81))
+    self.CHECK_pow(Interval(2,oo), 4, Interval(16,oo))
+    self.CHECK_pow(Interval(-oo,oo), 3, Interval(-oo,oo))
+    self.CHECK_pow(Interval.empty(), 3, Interval.empty())
+    self.CHECK_pow(Interval(2,3), 3, Interval(8,27))
+    self.CHECK_pow(Interval(-2,3), 3, Interval(-8,27))
+    self.CHECK_pow(Interval(-3,2), 3, Interval(-27,8))
+    self.CHECK_pow(Interval(2,oo), 3, Interval(8,oo))
+    self.CHECK_pow(Interval(-10,10), -2, Interval(1.0/100,oo), sys.float_info.epsilon)
+
+    self.assertTrue(root(Interval(0,1),-1) == Interval(1.0,oo))
+    self.assertTrue(Approx(root(Interval(-27,-8),3)) == Interval(-3,-2))
+    self.assertTrue(root(Interval(-4,1),2) == Interval(0,1))
+    self.assertTrue(Approx(root(Interval(-8,1),3)) == Interval(-2,1))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Matrix.py

@@ -0,0 +1,81 @@
+#!/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 TestMatrix(unittest.TestCase):
+
+  def test_def_Matrix(self):
+
+    x = Matrix([
+      [ 1, 2 ],
+      [ 3, 4 ],
+    ])
+
+    x[0,1] = 42
+    x[1,1] = 42
+
+    self.assertTrue(x == Matrix([
+      [ 1, 42 ],
+      [ 3, 42 ],
+    ]))
+
+    # The following simple call was a problem before
+    # (order of def of constructors):
+    m = Matrix(x)
+
+
+  def test_fnc_Matrix(self):
+
+    x = Matrix([
+      [ -1, 3  ],
+      [ -6, -9 ]
+    ])
+
+    self.assertTrue(abs(x) == Matrix([
+      [ 1, 3 ],
+      [ 6, 9 ]
+    ]))
+
+    y = Matrix([
+      [ -1.2, 3.9  ],
+      [ -6.2, -9.0 ]
+    ])
+
+    self.assertTrue(floor(y) == Matrix([
+      [ -2, 3  ],
+      [ -7, -9 ]
+    ]))
+
+    self.assertTrue(ceil(y) == Matrix([
+      [ -1, 4  ],
+      [ -6, -9 ]
+    ]))
+
+    self.assertTrue(round(y) == Matrix([
+      [ -1, 4  ],
+      [ -6, -9 ]
+    ]))
+
+  def test_def_Matrix_zero_init(self):
+
+    x = Matrix(2,2)
+    print(x)
+    self.assertTrue(x(0,0) == 0)
+    self.assertTrue(x(1,0) == 0)
+    self.assertTrue(x(0,1) == 0)
+    self.assertTrue(x(1,1) == 0)
+
+    v = Vector(2)
+    self.assertTrue(v[0] == 0)
+    self.assertTrue(v[1] == 0)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_OctaSym.py

@@ -0,0 +1,41 @@
+#!/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 TestOctaSym(unittest.TestCase):
+  
+  def test_OctaSym(self):
+
+    a = OctaSym([-2,1])
+    self.assertTrue(a.invert() == OctaSym([2,-1]))
+
+    x = IntervalVector([[-1,1],[5,6]])
+    self.assertTrue(a(x) == IntervalVector([[-6,-5],[-1,1]]))
+    self.assertTrue(a.invert()(a(x)) == x)
+
+    b = OctaSym([2,-1])
+    self.assertTrue(b.invert() == OctaSym([-2,1]))
+    self.assertTrue(b*b == OctaSym([-1,-2]))
+
+    c = OctaSym([-2,1,3])
+    self.assertTrue(c.permutation_matrix() == Matrix([[0,-1,0],[1,0,0],[0,0,1]]))
+
+  def test_OctaSym_as_operator(self):
+
+    a = OctaSym([3,1,-2])
+    x = VectorVar(3)
+    f = AnalyticFunction([x], a(2*x))
+    self.assertTrue(f.eval(IntervalVector([[1],[2],[3]])) == IntervalVector([[6],[2],[-4]]))
+    self.assertTrue(f.eval(IntervalVector([[-oo,oo],[-oo,oo],[-oo,oo]])) == IntervalVector(3))
+    self.assertTrue(f.eval(IntervalVector.empty(3)) == IntervalVector.empty(3))
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Parallelepiped.py

@@ -0,0 +1,35 @@
+#!/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 TestParallelepiped(unittest.TestCase):
+
+  def test_parallelepiped(self):
+
+    p = Parallelepiped(Vector([0,2,4]), Matrix([[0.5,0,0],[0,1,0],[0,1,1]]))
+
+    self.assertTrue(p.box() == IntervalVector([[-0.5,0.5],[1,3],[2,6]]))
+    self.assertTrue((p.contains(Vector([0.1,2.1,4.1])))==BoolInterval.TRUE)
+    self.assertTrue((p.contains(Vector([20.,20.,20.])))==BoolInterval.FALSE)
+
+    self.assertTrue((p.is_superset(IntervalVector([[0.,0.1],[2.,2.1],[4.,4.1]])))==BoolInterval.TRUE)
+    self.assertTrue((p.is_superset(IntervalVector([[-10.,-9.],[15.,16.],[12.,13.]])))==BoolInterval.FALSE)
+    self.assertTrue((p.is_superset(IntervalVector([[0.,5.],[2.,7.],[4.,9.]])))==BoolInterval.UNKNOWN)
+
+    z = p.proj([2,1,0])
+    self.assertTrue(z.z == Vector([4,2,0]))
+    self.assertTrue(z.A == Matrix([[0,1,1],[0,1,0],[0.5,0,0]]))
+    self.assertTrue(z.box() == IntervalVector([[2,6],[1,3],[-0.5,0.5]]))
+      
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Parallelepiped_eval.py

@@ -0,0 +1,62 @@
+#!/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 TestParallelepipedEval(unittest.TestCase):
+
+  def test_parallelepiped_eval(self):
+    x1 = ScalarVar()
+    x2 = ScalarVar()
+    x = VectorVar(2)
+
+    f1 = AnalyticFunction([x1], [x1,sqr(x1)])
+
+    f2 = AnalyticFunction([x1,x2], [x1, x2, sqr(x1)+sqr(x2)])
+    f3 = AnalyticFunction([x], [x[0], x[1], sqr(x[0])+sqr(x[1])])
+
+    p1a = f1.parallelepiped_eval(Interval(-0.1,0.1))
+    p1b = f1.parallelepiped_eval(1.0)
+    
+    self.assertTrue(Approx(p1a.z,1e-6)==Vector([0.0,0.0]))
+    self.assertTrue(Approx(p1a.A,1e-6)==Matrix([[0.12,0.0],[0.0,0.02]]))
+    self.assertTrue(Approx(p1b.z,1e-6)==Vector([1.0,1.0]))
+    self.assertTrue(Approx(p1b.A,1e-6)==Matrix([[0.0,0.0],[0.0,0.0]]))
+
+    pa = f2.parallelepiped_eval(Interval(-0.1,0.1), Interval(-0.1,0.1))
+    pb = f2.parallelepiped_eval(1.0,Interval(-1,1))
+
+    self.assertTrue(Approx(pa.z,1e-6)==Vector([0,0,0]))
+    self.assertTrue(Approx(pa.A,1e-6)==Matrix([[0.14,0,0],[0,0.14,0],[0,0,0.04]]))
+    self.assertTrue(Approx(pb.z,1e-6)==Vector([1,0,1]))
+    self.assertTrue(Approx(pb.A,1e-5)==Matrix([[0.894428,0,1.78886],[0,3,0],[1.78886,0,-0.894427]]))
+
+
+    dx = 0.4
+    x0 = -2.0
+    while x0<2.0:
+      X0 = Interval(x0,x0+dx)
+      y0 = -2.0
+      while y0<2.0:
+        Y0 = Interval(y0,y0+dx)
+        
+        p2 = f2.parallelepiped_eval(X0,Y0)
+        p3 = f3.parallelepiped_eval(IntervalVector([X0,Y0]))
+
+        self.assertTrue(Approx(p2.z,1e-6)==p3.z)
+        self.assertTrue(Approx(p2.A,1e-6)==p3.A)
+        y0 += dx
+      x0 += dx
+    
+      
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_Polygon.py

@@ -0,0 +1,120 @@
+#!/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 TestPolygon(unittest.TestCase):
+
+  def test_polygon_base(self):
+
+    p1 = Polygon([[3,4]])
+    self.assertTrue(p1 == Polygon([[3,4]]))
+
+    p2 = Polygon([[3,4],[1,2]])
+    self.assertTrue(p2 == Polygon([[3,4],[1,2]]))
+    self.assertTrue(p2 == Polygon([[1,2],[3,4]]))
+
+    p3 = Polygon([[3,4],[1,2],[5,1]])
+    self.assertTrue(p3 == Polygon([[3,4],[1,2],[5,1]]))
+    self.assertTrue(p3 == Polygon([[1,2],[5,1],[3,4]]))
+    self.assertTrue(p3 == Polygon([[5,1],[1,2],[3,4]]))
+    self.assertTrue(p3 == Polygon([[1,2],[3,4],[5,1]]))
+
+  def test_empty_polygon(self):
+
+    p1 = Polygon.empty()
+    self.assertTrue(p1.contains(IntervalVector([1,1])) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains(IntervalVector(2)) == BoolInterval.FALSE)
+    self.assertTrue(p1.is_empty())
+    self.assertTrue(len(p1.edges()) == 0)
+    self.assertTrue(len(p1.vertices()) == 0)
+
+  def test_Polygon(self):
+
+    p1 = Polygon([[3,-1],[3,4],[5,6],[-1,1]])
+    self.assertTrue(p1.contains([3.1,3]) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains([2.9,3]) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains([3,3]) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains([0,1]) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains([4,1]) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains([2,4]) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains([2.8,4]) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains([3,4]) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains([4,4]) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains([5,6]) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains([6,6]) == BoolInterval.FALSE)
+
+    transect = Segment(Vector([next_float(-oo),3]), Vector([3,3]))
+    e1,e2 = Segment(Vector([5,6]),Vector([-1,1])), Segment(Vector([3,-1]),Vector([3,4]))
+    self.assertTrue(transect.intersects(e1) == BoolInterval.TRUE)
+    self.assertTrue(transect.intersects(e2) == BoolInterval.TRUE)
+
+    p2 = Polygon([[0,0],[0,1],[1,1],[1,0]])
+    self.assertTrue(p2.contains([0,0]) == BoolInterval.TRUE)
+    self.assertTrue(p2.contains([1,1]) == BoolInterval.TRUE)
+    self.assertTrue(p2.contains([0,2]) == BoolInterval.FALSE)
+    self.assertTrue(p2.contains([2,0]) == BoolInterval.FALSE)
+    self.assertTrue(p2.contains([0.5,1]) == BoolInterval.TRUE)
+    self.assertTrue(p2.contains([1,0.5]) == BoolInterval.TRUE)
+
+    transect = Segment(Vector([next_float(-oo),2]), Vector([0,2]))
+    e1 = Segment(Vector([0,0]),Vector([0,1]))
+    e2 = Segment(Vector([0,1]),Vector([1,1]))
+    e3 = Segment(Vector([1,1]),Vector([1,0]))
+    e4 = Segment(Vector([1,0]),Vector([0,0]))
+
+    self.assertTrue(transect.intersects(e1) == BoolInterval.FALSE)
+    self.assertTrue(transect.intersects(e2) == BoolInterval.FALSE)
+    self.assertTrue(transect.intersects(e3) == BoolInterval.FALSE)
+    self.assertTrue(transect.intersects(e4) == BoolInterval.FALSE)
+
+    p3 = Polygon([[0,1],[1,0],[0,0]])
+    self.assertTrue(p3.contains([1,1]) == BoolInterval.FALSE)
+
+  def test_Polygon_degenerated_cases(self):
+
+    p1 = Polygon([[1,1]])
+    self.assertTrue(p1.contains(IntervalVector([1,1])) == BoolInterval.TRUE)
+    self.assertTrue(p1.contains(IntervalVector([2,1])) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains(IntervalVector([2,2])) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains(IntervalVector([1,2])) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains(IntervalVector([-10,1])) == BoolInterval.FALSE)
+    self.assertTrue(p1.contains(IntervalVector([10,1])) == BoolInterval.FALSE)
+
+    p2 = Polygon([[1,1],[3,2]])
+    self.assertTrue(p2.contains(IntervalVector([1,1])) == BoolInterval.TRUE)
+    self.assertTrue(p2.contains(IntervalVector([3,2])) == BoolInterval.TRUE)
+    self.assertTrue(p2.contains(IntervalVector([2,1.5])) == BoolInterval.TRUE)
+
+    p3 = Polygon([[1,1],[3,1]])
+    self.assertTrue(p3.contains(IntervalVector([1,1])) == BoolInterval.TRUE)
+    self.assertTrue(p3.contains(IntervalVector([3,1])) == BoolInterval.TRUE)
+    self.assertTrue(p3.contains(IntervalVector([2,1])) == BoolInterval.TRUE)
+
+    p4 = Polygon([[1,1],[1,3]])
+    self.assertTrue(p4.contains(IntervalVector([1,1])) == BoolInterval.TRUE)
+    self.assertTrue(p4.contains(IntervalVector([1,3])) == BoolInterval.TRUE)
+    self.assertTrue(p4.contains(IntervalVector([1,2])) == BoolInterval.TRUE)
+
+  def test_Polygon_limit_case(self):
+
+    x = Vector([5,3.5])
+    p = Polygon([[4,3.5],[5,4],[4,4.5]])
+    self.assertTrue(p.contains(x) == BoolInterval.FALSE)
+
+    p1 = ConvexPolygon([[4,3.5],[5,4],[4.5,4.25],[4,4]])
+    self.assertTrue(p1.contains([4.5,4.25]) == BoolInterval.TRUE)
+    p2 = ConvexPolygon([[4,4.25],[5,4.25]])
+    i = p1 & p2
+    self.assertTrue(i == ConvexPolygon(IntervalVector([4.5,4.25])))
+    self.assertTrue(len(i.vertices()) == 1)
+
+if __name__ ==  '__main__':
+  unittest.main()