codac4matlab 2.0.0.dev14__cp313-cp313-win32.whl

codac4matlab/tests/test_operators.py

@@ -0,0 +1,348 @@
+#!/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_bwd(unittest.TestCase):
+
+  def CHECK_bwd_trigo(self, y, x, expected_x):
+    _x = Interval()
+    _x = x; SinOp.bwd(y,_x); self.assertTrue(Approx(_x, 1e-5) == expected_x)
+    _x = -x; SinOp.bwd(-y,_x); self.assertTrue(Approx(_x, 1e-5) == -expected_x)
+    _x = x-Interval.half_pi(); CosOp.bwd(y,_x); self.assertTrue(Approx(_x, 1e-5) == expected_x-Interval.half_pi())
+    _x = x+Interval.half_pi(); CosOp.bwd(-y,_x); self.assertTrue(Approx(_x, 1e-5) == expected_x+Interval.half_pi())
+
+  def CHECK_bwd_pow(self, y, x, expected_x, p):
+    _x = Interval()
+    _x = x; PowOp.bwd(y,_x,p); self.assertTrue(Approx(_x,1e-5) == expected_x)
+    _x = -x;
+    if p%2 == 0:
+      PowOp.bwd(y,_x,p);
+    else:
+      PowOp.bwd(-y,_x,p);
+    self.assertTrue(Approx(_x,1e-5) == -expected_x)
+
+  def CHECK_bwd_mul(self, y, x1, x2, expected_x1, expected_x2):
+    _x1 = Interval(); _x2 = Interval()
+
+    _x1 = x1; _x2 = x2; MulOp.bwd(y,_x1,_x2)
+    self.assertTrue(Approx(_x1) == expected_x1)
+    self.assertTrue(Approx(_x2) == expected_x2)
+
+    _x1 = x1; _x2 = x2; MulOp.bwd(y,_x2,_x1)
+    self.assertTrue(Approx(_x1) == expected_x1)
+    self.assertTrue(Approx(_x2) == expected_x2)
+
+    _x1 = -x1; _x2 = x2; MulOp.bwd(-y,_x2,_x1)
+    self.assertTrue(Approx(_x1) == -expected_x1)
+    self.assertTrue(Approx(_x2) == expected_x2)
+
+    _x1 = x1; _x2 = -x2; MulOp.bwd(-y,_x2,_x1)
+    self.assertTrue(Approx(_x1) == expected_x1)
+    self.assertTrue(Approx(_x2) == -expected_x2)
+
+  def CHECK_bwd_div(self, y, x1, x2, expected_x1, expected_x2):
+    _x1 = Interval(); _x2 = Interval()
+
+    _x1 = x1; _x2 = x2; DivOp.bwd(y,_x1,_x2)
+    self.assertTrue(Approx(_x1) == expected_x1)
+    self.assertTrue(Approx(_x2) == expected_x2)
+
+    _x1 = -x1; _x2 = -x2; DivOp.bwd(y,_x1,_x2)
+    self.assertTrue(Approx(_x1) == -expected_x1)
+    self.assertTrue(Approx(_x2) == -expected_x2)
+
+    _x1 = -x1; _x2 = x2; DivOp.bwd(-y,_x1,_x2)
+    self.assertTrue(Approx(_x1) == -expected_x1)
+    self.assertTrue(Approx(_x2) == expected_x2)
+
+    _x1 = x1; _x2 = -x2; DivOp.bwd(-y,_x1,_x2)
+    self.assertTrue(Approx(_x1) == expected_x1)
+    self.assertTrue(Approx(_x2) == -expected_x2)
+
+  def CHECK_bwd_max(self, y, x1, x2, expected_x1, expected_x2):
+    _x1 = Interval(); _x2 = Interval()
+
+    _x1 = x1; _x2 = x2; MaxOp.bwd(y,_x1,_x2)
+    self.assertTrue(_x1 == expected_x1)
+    self.assertTrue(_x2 == expected_x2)
+
+    _x1 = x1; _x2 = x2; MaxOp.bwd(y,_x2,_x1)
+    self.assertTrue(_x1 == expected_x1)
+    self.assertTrue(_x2 == expected_x2)
+
+    _x1 = -x1; _x2 = -x2; MinOp.bwd(-y,_x1,_x2)
+    self.assertTrue(_x1 == -expected_x1)
+    self.assertTrue(_x2 == -expected_x2)
+
+    _x1 = -x1; _x2 = -x2; MinOp.bwd(-y,_x2,_x1)
+    self.assertTrue(_x1 == -expected_x1)
+    self.assertTrue(_x2 == -expected_x2)
+
+  def CHECK_bwd_atan(self, y, x, expected_x):
+    _x = Interval()
+
+    _x = x; AtanOp.bwd(y,_x)
+    self.assertTrue(_x == expected_x)
+
+    _x = -x; AtanOp.bwd(-y,_x)
+    self.assertTrue(_x == -expected_x)
+
+  def CHECK_bwd_add(self, y, x1, x2, expected_x1, expected_x2):
+    _x1 = Interval(); _x2 = Interval()
+
+    _x1 = x1; _x2 = x2; AddOp.bwd(y,_x1,_x2)
+    self.assertTrue(_x1 == expected_x1)
+    self.assertTrue(_x2 == expected_x2)
+
+    _x1 = x1; _x2 = x2; AddOp.bwd(y,_x2,_x1)
+    self.assertTrue(_x1 == expected_x1)
+    self.assertTrue(_x2 == expected_x2)
+
+    _x1 = -x1; _x2 = -x2; AddOp.bwd(-y,_x1,_x2)
+    self.assertTrue(_x1 == -expected_x1)
+    self.assertTrue(_x2 == -expected_x2)
+
+    _x1 = -x1; _x2 = -x2; AddOp.bwd(-y,_x2,_x1)
+    self.assertTrue(_x1 == -expected_x1)
+    self.assertTrue(_x2 == -expected_x2)
+
+  def CHECK_bwd_sub(self, y, x1, x2, expected_x1, expected_x2):
+    _x1 = Interval(); _x2 = Interval()
+
+    _x1 = x1; _x2 = x2; SubOp.bwd(y,_x1,_x2)
+    self.assertTrue(_x1 == expected_x1)
+    self.assertTrue(_x2 == expected_x2)
+
+    _x1 = -x1; _x2 = -x2; SubOp.bwd(-y,_x1,_x2)
+    self.assertTrue(_x1 == -expected_x1)
+    self.assertTrue(_x2 == -expected_x2)
+
+    _x1 = x1; _x2 = x2; SubOp.bwd(-y,_x2,_x1)
+    self.assertTrue(_x1 == expected_x1)
+    self.assertTrue(_x2 == expected_x2)
+
+    _x1 = -x1; _x2 = -x2; SubOp.bwd(y,_x2,_x1)
+    self.assertTrue(_x1 == -expected_x1)
+    self.assertTrue(_x2 == -expected_x2)
+
+  def CHECK_bwd_imod(self, p, x1, x2, expected_x1, expected_x2):
+    _x1 = Interval(); _x2 = Interval()
+    _x1 = x1; _x2 = x2; ModOp.bwd(_x1,_x2,p)
+    self.assertTrue(Approx(_x1) == expected_x1)
+    self.assertTrue(Approx(_x2) == expected_x2)
+
+  def tests_interval_bwd(self):
+
+    pi_lb = Interval.pi().lb()
+    pi_ub = Interval.pi().ub()
+
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(0,pi_ub/2.0),          Interval(0.5,1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(0,5*pi_ub/2.0),        Interval(0.5,2*pi_ub+1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-2*pi_ub,pi_ub/2.0),   Interval(-2*pi_ub+0.5,1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-2*pi_ub,5*pi_ub/2.0), Interval(-2*pi_ub+0.5,2*pi_ub+1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-pi_lb-0.4,pi_ub/2.0), Interval(0.5,1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-pi_ub-0.5,pi_ub/2.0), Interval(-pi_ub-0.5,1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-3*pi_ub/2,pi_ub/2.0), Interval(-pi_ub-1.5,1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(0.5,pi_lb-1.6),        Interval(0.5,1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(0.5,pi_ub-1.5),        Interval(0.5,pi_ub-1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(0.5,pi_ub),            Interval(0.5,pi_ub-0.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-pi_ub-0.5,pi_ub-1.5), Interval(-pi_ub-0.5,pi_ub-1.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-3*pi_ub/2,pi_ub),     Interval(-pi_ub-1.5,pi_ub-0.5))
+    self.CHECK_bwd_trigo(sin(Interval(0.5,1.5)), Interval(-pi_ub/2,pi_ub/2.0),   Interval(0.5,1.5))
+    self.CHECK_bwd_trigo(Interval(2,3),          Interval(-oo,oo),               Interval.empty())
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(0,pi_ub/2.0),          Interval(0.5,pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(0,5*pi_ub/2.0),        Interval(0.5,5*pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(-2*pi_ub,pi_ub/2.0),   Interval(-2*pi_ub+0.5,pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(-2*pi_ub,5*pi_ub/2.0), Interval(-2*pi_ub+0.5,5*pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(-pi_lb-0.4,pi_ub/2.0), Interval(0.5,pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(-pi_ub-0.5,pi_ub/2.0), Interval(-pi_ub-0.5,pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(-3*pi_ub/2,pi_ub/2.0), Interval(-3*pi_ub/2,pi_ub/2.0))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(0.5,pi_ub),            Interval(0.5,pi_ub-0.5))
+    self.CHECK_bwd_trigo(Interval(math.sin(0.5),1.0), Interval(-3*pi_ub/2,pi_ub),     Interval(-3*pi_ub/2,pi_ub-0.5))
+    self.CHECK_bwd_trigo(Interval(1.0),          Interval(4.0,6.0),              Interval.empty())
+
+    x = Interval()
+
+    x = Interval(0,4);    SqrOp.bwd(Interval(1,9),x);   self.assertTrue(x == Interval(1,3))
+    x = Interval(0,2);    SqrOp.bwd(Interval(1,9),x);   self.assertTrue(x == Interval(1,2))
+    x = Interval(-4,2);   SqrOp.bwd(Interval(1,9),x);   self.assertTrue(x == Interval(-3,2))
+    x = Interval(-4,-3);  SqrOp.bwd(Interval(1,9),x);   self.assertTrue(x == Interval(-3,-3))
+    x = Interval(-4,1);   SqrOp.bwd(Interval(-oo,9),x); self.assertTrue(x == Interval(-3,1))
+    x = Interval(-1,5);   SqrOp.bwd(Interval(4,9),x);   self.assertTrue(x == Interval(2,3))
+    x = Interval(-oo,oo); SqrOp.bwd(Interval(-4,-2),x); self.assertTrue(x == Interval.empty())
+
+    x = Interval(-oo,oo);     LogOp.bwd(Interval(-oo,oo),x); self.assertTrue(x == Interval(0,oo))
+    x = Interval(-oo,oo);     LogOp.bwd(Interval(-oo,0),x);  self.assertTrue(x == Approx(Interval(0,1)))
+    x = Interval(0,1);        LogOp.bwd(Interval(0,oo),x);   self.assertTrue(x == Approx(Interval(1)))
+    x = Interval(-1,3);       LogOp.bwd(Interval(0,1),x);    self.assertTrue(x == Approx(Interval(1,math.exp(1.))))
+    x = Interval(-1,3);       LogOp.bwd(Interval(-oo,1),x);  self.assertTrue(x == Approx(Interval(0,math.exp(1.))))
+    x = Interval(-1,2);       LogOp.bwd(Interval(-oo,1),x);  self.assertTrue(x == Interval(0,2))
+    x = Interval(3,4);        LogOp.bwd(Interval(-oo,1),x);  self.assertTrue(x == Interval.empty())
+    x = Interval(-0.01,0.01); LogOp.bwd(Interval(-1,1),x);   self.assertTrue(x == Interval.empty())
+
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(1,4),    Interval(2,3), 4)
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(3,4),    Interval(3,3), 4)
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(-1,4),   Interval(2,3), 4)
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(-2,4),   Interval(-2,3), 4)
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(-5,4),   Interval(-3,3), 4)
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(1,1),    Interval.empty(), 4)
+    self.CHECK_bwd_pow(Interval(16,81),  Interval(4,4),    Interval.empty(), 4)
+    self.CHECK_bwd_pow(Interval(8,27),   Interval(1,4),    Interval(2,3), 3)
+    self.CHECK_bwd_pow(Interval(8,27),   Interval(3,4),    Interval(3,3), 3)
+    self.CHECK_bwd_pow(Interval(8,27),   Interval(-5,4),   Interval(2,3), 3)
+    self.CHECK_bwd_pow(Interval(-8,27),  Interval(-5,4),   Interval(-2,3), 3)
+    self.CHECK_bwd_pow(Interval(-27,27), Interval(-5,4),   Interval(-3,3), 3)
+    self.CHECK_bwd_pow(Interval(8,27),   Interval(1,1),    Interval.empty(), 3)
+    self.CHECK_bwd_pow(Interval(8,27),   Interval(4,4),    Interval.empty(), 3)
+    self.CHECK_bwd_pow(Interval(-27,-8), Interval(-1,-1),  Interval.empty(), 3)
+    self.CHECK_bwd_pow(Interval(-27,-8), Interval(-4,-4),  Interval.empty(), 3)
+    self.CHECK_bwd_pow(Interval(0,1),    Interval(-10,10), Interval(-10,10), -2)
+
+    self.CHECK_bwd_mul(Interval(1,2),Interval(0.1,2.0),Interval(-10,2),Interval(0.5,2.0),Interval(0.5,2))
+    self.CHECK_bwd_mul(Interval.empty(),Interval(0.1,2.0),Interval(-10,2),Interval.empty(),Interval.empty())
+    self.CHECK_bwd_mul(Interval(0,0),Interval(0.1,2.0),Interval(-10,2),Interval(0.1,2.0),Interval(0,0))
+    self.CHECK_bwd_mul(Interval(0,0),Interval(-1,1),Interval(-1,1),Interval(-1,1),Interval(-1,1))
+    self.CHECK_bwd_mul(Interval(1,1),Interval(0,10),Interval(0,10),Interval(0.1,10.0),Interval(0.1,10.0))
+
+    self.CHECK_bwd_div(Interval(1,2), Interval(0,1), Interval(2,3), Interval.empty(), Interval.empty())
+    self.CHECK_bwd_div(Interval(1,2), Interval(0,1), Interval(1,3), 1., 1.)
+    self.CHECK_bwd_div(Interval(1,2), Interval(1,3), Interval(0,1), Interval(1,2), Interval(0.5,1))
+    self.CHECK_bwd_div(Interval(-1,1), Interval(-2,2), Interval(0,1), Interval(-1,1), Interval(0,1))
+    self.CHECK_bwd_div(Interval(-1,1), Interval(-2,2), 0., 0., 0.)
+    self.CHECK_bwd_div(0, Interval(-2,2), Interval(-2,2), 0, Interval(-2,2))
+    self.CHECK_bwd_div(Interval(0,oo), Interval(0,1), Interval(-1,0), 0, Interval(-1,0))
+    self.CHECK_bwd_div(Interval(next_float(0.),oo), Interval(0,1), Interval(-1,0), 0, 0)
+    self.CHECK_bwd_div(Interval(0,oo), Interval(next_float(0.),1), Interval(-1,0), Interval.empty(), Interval.empty())
+
+    self.CHECK_bwd_max(Interval.empty(), Interval(-2,-1), Interval(-2,3), Interval.empty(), Interval.empty())
+    self.CHECK_bwd_max(Interval(0,1), Interval(-2,-1), Interval(-2,3), Interval(-2,-1), Interval(0,1))
+    self.CHECK_bwd_max(Interval(0,1), Interval(-2,-1), Interval(2,3), Interval.empty(), Interval.empty())
+    self.CHECK_bwd_max(Interval(0,1), Interval(-2,0), Interval(-2,3), Interval(-2,0), Interval(-2,1))
+    self.CHECK_bwd_max(Interval(0,1), Interval(-2,2), Interval(-2,3), Interval(-2,1), Interval(-2,1))
+
+    a = Interval(); y = Interval()
+
+    a = Interval(math.pi/6.,math.pi/3.); y = Interval(.5,10.); x = Interval(.5,2.);             
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(.5,2.*math.sqrt(3.))); self.assertTrue(Approx(x) == Interval(.5,2.))
+    a = Interval(math.pi/6.,math.pi/3.); y = Interval(.5,2.); x = Interval(.5,10.);            
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(.5,2.)); self.assertTrue(Approx(x) == Interval(.5,2.*math.sqrt(3.)))
+    a = Interval(-math.pi/4.,math.pi/4.); y = Interval(1.,2.); x = Interval(.5,2.);             
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(1.,2.)); self.assertTrue(Approx(x) == Interval(1.,2.))
+    a = Interval(-math.pi/2.,0.); y = Interval(.5,2.); x = Interval(.5,10.);            
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval.empty()); self.assertTrue(Approx(x) == Interval.empty())
+    a = Interval(2.*math.pi,3.*math.pi); y = Interval(-.5,2.); x = Interval(.5,10.);            
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval.empty()); self.assertTrue(Approx(x) == Interval.empty())
+    a = Interval(2*math.pi/3.,5.*math.pi/6.); y = Interval(0.,100.); x = Interval(-20.,-math.sqrt(3.)/2.); 
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y,1e-10) == Interval(.5,20.*math.sqrt(3.))); self.assertTrue(Approx(x) == Interval(-20.,-math.sqrt(3.)/2))
+    a = Interval(-3*math.pi/4.,-2*math.pi/3.); y = Interval(-math.sqrt(3.)/2.,2.); x = Interval(-math.sqrt(2.)/2.,0.);   
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(-math.sqrt(3.)/2.,0.)); self.assertTrue(Approx(x) == Interval(-math.sqrt(2.)/2.,0.))
+    a = Interval(-3*math.pi/4.,-2*math.pi/3.); y = Interval(-math.sqrt(3.)/2.,2.); x = Interval(-1.,-.5);           
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(-math.sqrt(3.)/2.,-.5)); self.assertTrue(Approx(x) == Interval(-math.sqrt(3.)/2.,-.5))
+    a = Interval(-3*math.pi/4.,-math.pi/4.); y = Interval(-5.,-.5); x = Interval(-oo,oo);            
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(-5.,-.5)); self.assertTrue(Approx(x) == Interval(-5.,5.))
+    a = Interval(-math.pi/3.,math.pi/4.); y = Interval(-oo,oo); x = Interval(sqrt(3.)/2.);       
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == Interval(-1.5,math.sqrt(3.)/2.)); self.assertTrue(Approx(x) == Interval(math.sqrt(3.)/2.))
+    a = Interval.half_pi(); y = Interval(1); x = 0.;                          
+    Atan2Op.bwd(a,y,x); self.assertTrue(Approx(y) == 1.); self.assertTrue(Approx(x) == 0.)
+
+    x = Interval(0,15);   SqrtOp.bwd(Interval(1,3), x);   self.assertTrue(x == Interval(1,9))
+    x = Interval(0,2);    SqrtOp.bwd(Interval(1,3), x);   self.assertTrue(x == Interval(1,2))
+    x = Interval(-4,2);   SqrtOp.bwd(Interval(1,3), x);   self.assertTrue(x == Interval(1,2))
+    x = Interval(-4,-3);  SqrtOp.bwd(Interval(1,3), x);   self.assertTrue(x == Interval.empty())
+    x = Interval(-4,1);   SqrtOp.bwd(Interval(-oo,9), x); self.assertTrue(x == Interval(0,1))
+    x = Interval(-1,5);   SqrtOp.bwd(Interval(2,5), x);   self.assertTrue(x == Interval(4,5))
+    x = Interval(-oo,oo); SqrtOp.bwd(Interval(-4,-2), x); self.assertTrue(x == Interval.empty())
+
+    x = Interval(-1.,3.);       AtanOp.bwd(Interval(0.,math.pi/6.),x);                self.assertTrue(x == tan(Interval(0.,math.pi/6.)))
+    x = Interval(0,5*math.pi/2.0); AtanOp.bwd(Interval(-math.pi,1.5),x);              self.assertTrue(x == Interval(0,5*math.pi/2.0))
+    x = Interval(.2,.5);        AtanOp.bwd(Interval(0.,math.pi/6.),x);                self.assertTrue(x == Interval(.2,.5))
+    x = Interval(-100,100);     AtanOp.bwd(Interval(-math.pi/2-0.1,math.pi/2+0.1),x); self.assertTrue(x == Interval(-100,100))
+    x = Interval(-100,100);     AtanOp.bwd(Interval(math.pi/2+0.1,math.pi),x);        self.assertTrue(x == Interval.empty())
+    x = Interval(-100,100);     AtanOp.bwd(Interval(-math.pi,-math.pi/2-0.1),x);      self.assertTrue(x == Interval.empty())
+
+
+    x = Interval(-oo,oo); AtanOp.bwd(Interval(-math.pi/4,math.pi/2.), x); self.assertTrue(x.lb() == -1); self.assertTrue(x.ub() > 1000)
+    x = Interval(-oo,oo); AtanOp.bwd(Interval(-math.pi/2,math.pi/4.), x); self.assertTrue(x.ub() == +1); self.assertTrue(x.lb() < -1000)
+
+    self.CHECK_bwd_add(Interval(1,3),Interval(1,2),Interval(-10,5),Interval(1,2),Interval(-1,2))
+    self.CHECK_bwd_add(Interval.empty(),Interval(0.1,2.0),Interval(-10,2),Interval.empty(),Interval.empty())
+    self.CHECK_bwd_add(Interval(0,0),Interval(0,0),Interval(.1,5),Interval.empty(),Interval.empty())
+    self.CHECK_bwd_add(Interval(0,0),Interval(-1,1),Interval(-1,1),Interval(-1,1),Interval(-1,1))
+    self.CHECK_bwd_add(Interval(-1,1),Interval(1,2),Interval(-10,5),Interval(1,2),Interval(-3,0))
+
+    self.CHECK_bwd_sub(Interval(1,3),Interval(1,2),Interval(-10,5),Interval(1,2),Interval(-2,1))
+    self.CHECK_bwd_sub(Interval.empty(),Interval(0.1,2.0),Interval(-10,2),Interval.empty(),Interval.empty())
+    self.CHECK_bwd_sub(Interval(0,0),Interval(0,0),Interval(.1,5),Interval.empty(),Interval.empty())
+    self.CHECK_bwd_sub(Interval(0,0),Interval(-1,1),Interval(-1,1),Interval(-1,1),Interval(-1,1))
+    self.CHECK_bwd_sub(Interval(-1,1),Interval(1,2),Interval(-10,5),Interval(1,2),Interval(0,3))
+
+    self.CHECK_bwd_imod(3.,Interval(3.,5.),Interval(1.,2.),Interval(4.,5.),Interval(1.,2.))
+    self.CHECK_bwd_imod(2.,Interval(7.,8.),Interval(.5,2.),Interval(7.,8.),Interval(1.,2.))
+    self.CHECK_bwd_imod(2.,Interval(7.,8.),Interval(0.,2.),Interval(7.,8.),Interval(0.,2.))
+    self.CHECK_bwd_imod(2.*math.pi,Interval(2.*math.pi,3.*math.pi),Interval(math.pi/6,math.pi/2.),Interval(13.*math.pi/6.,5.*math.pi/2.),Interval(math.pi/6,math.pi/2.))
+    self.CHECK_bwd_imod(2.*math.pi,Interval(3.*math.pi,4.*math.pi),Interval(math.pi/3,math.pi/2.),Interval.empty(),Interval.empty())
+    self.CHECK_bwd_imod(2.*math.pi,Interval(3.*math.pi,4.*math.pi),Interval(0.,math.pi/2.),Interval(4*math.pi),Interval(0.))
+    self.CHECK_bwd_imod(2.*math.pi,Interval(2.*math.pi,4.*math.pi),Interval(-math.pi/6,math.pi/2.),Interval(2.*math.pi,4.*math.pi),Interval(-math.pi/6,math.pi/2.))
+    self.CHECK_bwd_imod(2.*math.pi,Interval(7.*math.pi/4.,8.*math.pi/3),Interval(-math.pi/2,math.pi/2.),Interval(7.*math.pi/4.,5.*math.pi/2.),Interval(-math.pi/4,math.pi/2.))
+
+    x = Interval(-oo,oo);        FloorOp.bwd(Interval.empty(),x);        self.assertTrue(x == Interval.empty())
+    x = Interval(-oo,-0.000001); FloorOp.bwd(Interval(-oo,-1),x);        self.assertTrue(x == Interval(-oo,-0.000001))
+    x = Interval(-oo, 0.000001); FloorOp.bwd(Interval(-oo,-1),x);        self.assertTrue(x == Interval(-oo,0))
+    x = Interval(-oo, 0.000001); FloorOp.bwd(Interval(-oo,-0.000001),x); self.assertTrue(x == Interval(-oo,0))
+    x = Interval(0.000001,oo);   FloorOp.bwd(Interval(1,oo),x);          self.assertTrue(x == Interval(1,oo))
+    x = Interval(-0.000001,oo);  FloorOp.bwd(Interval(1,oo),x);          self.assertTrue(x == Interval(1,oo))
+    x = Interval(-0.000001,oo);  FloorOp.bwd(Interval(0.000001,oo),x);   self.assertTrue(x == Interval(1,oo))
+    x = Interval(0.01,2.99);     FloorOp.bwd(Interval(1,2),x);           self.assertTrue(x == Interval(1,2.99))
+    x = Interval(2.99,3.01);     FloorOp.bwd(Interval(1,2),x);           self.assertTrue(x == Interval(2.99,3))
+    x = Interval(3.01,3.99);     FloorOp.bwd(Interval(1,2),x);           self.assertTrue(x == Interval.empty())
+    x = Interval(0.01,2.99);     FloorOp.bwd(Interval(0.01,2.99),x);     self.assertTrue(x == Interval(1,2.99))
+
+    x = Interval(-oo,oo);        CeilOp.bwd(Interval.empty(),x);        self.assertTrue(x == Interval.empty())
+    x = Interval(-oo,-0.000001); CeilOp.bwd(Interval(-oo,-1),x);        self.assertTrue(x == Interval(-oo,-1))
+    x = Interval(-oo,0.000001);  CeilOp.bwd(Interval(-oo,-1),x);        self.assertTrue(x == Interval(-oo,-1))
+    x = Interval(-oo,0.000001);  CeilOp.bwd(Interval(-oo,-0.000001),x); self.assertTrue(x == Interval(-oo,-1))
+    x = Interval(0.000001,oo);   CeilOp.bwd(Interval(1,oo),x);          self.assertTrue(x == Interval(0.000001,oo))
+    x = Interval(-0.000001,oo);  CeilOp.bwd(Interval(1,oo),x);          self.assertTrue(x == Interval(0,oo))
+    x = Interval(-0.000001,oo);  CeilOp.bwd(Interval(0.000001,oo),x);   self.assertTrue(x == Interval(0,oo))
+    x = Interval(0.01,2.99);     CeilOp.bwd(Interval(1,2),x);           self.assertTrue(x == Interval(0.01,2))
+    x = Interval(-0.01,0.01);    CeilOp.bwd(Interval(1,2),x);           self.assertTrue(x == Interval(0,0.01))
+    x = Interval(-1.01,-0.01);   CeilOp.bwd(Interval(1,2),x);           self.assertTrue(x == Interval.empty())
+    x = Interval(0.01,2.99);     CeilOp.bwd(Interval(0.01,2.99),x);     self.assertTrue(x == Interval(0.01,2))
+    
+    x = Interval(-1.57079632679489678, 1.1780972450961728626)
+    self.assertFalse(tan(x).is_empty())
+
+  def tests_cross_prod(self):
+
+    self.assertTrue(
+      CrossProdOp.fwd(Vector([1,0,0]),Vector([0,1,0])) == Vector([0,0,1]))
+    self.assertTrue(
+      CrossProdOp.fwd(Vector([0,1,0]),Vector([0,0,1])) == Vector([1,0,0]))
+    self.assertTrue(
+      CrossProdOp.fwd(Vector([0,0,1]),Vector([1,0,0])) == Vector([0,1,0]))
+    self.assertTrue(
+      CrossProdOp.fwd(Vector([1,2,3]),Vector([2,4,6])) == Vector([0,0,0]))
+
+  def tests_mat_operator(self):
+
+    x1,x2,x3 = IntervalVector([2,3]), IntervalVector([4,5]), IntervalVector([6,7]) 
+    self.assertTrue(MatrixOp.fwd(x1,x2,x3) == IntervalMatrix([[2,4,6],[3,5,7]]))
+    self.assertTrue(MatrixOp.fwd(x1) == IntervalMatrix([[2],[3]]))
+  
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/tests/test_transformations.py

@@ -0,0 +1,61 @@
+#!/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
+
+class TestTransformations(unittest.TestCase):
+
+  def tests_affine_transformation(self):
+
+    # Building the src trajectory analytically
+    
+    t = ScalarVar()
+    f_src = AnalyticFunction([t], [
+      cos(2*t)+0.1*cos(10*t),
+      2*sin(t)+0.1*sin(10*t)
+    ])
+
+    src = AnalyticTraj(f_src,[-1,3]).sampled(0.01)
+
+    # The dst trajectory is obtained analytically with a
+    # transformation described by the parameters:
+
+    a = PI + PI/3 # rotation angle
+    b = 2.5 # scaling
+    T = Vector([ -3.2, 2.5 ]) # translation
+    f_dst = AnalyticFunction([t], [
+      b*cos(a)*f_src(t)[0]-b*sin(a)*f_src(t)[1] + T[0] + 0.05*cos(100*t),
+      b*sin(a)*f_src(t)[0]+b*cos(a)*f_src(t)[1] + T[1] + 0.05*sin(100*t)
+    ])
+
+    dst = AnalyticTraj(f_dst,[-1,3]).sampled(0.01)
+
+    # Computing the transformation
+
+    tr = affine_transformation(src, dst)
+
+    # Reconstructing the dst trajectory using the estimated transformation
+
+    dst_estim = SampledVectorTraj()
+    for ti,src_i in src:
+      dst_estim.set(ti, tr*src_i)
+
+    scale = tr.linear().col(0).norm()
+    rotation_matrix = tr.linear() / scale
+    rotation_angle = atan2(rotation_matrix(1, 0), rotation_matrix(0, 0))
+    translation = tr.translation()
+
+    self.assertTrue(Approx(scale,1e-3) == b)
+    self.assertTrue(Approx(rotation_angle,1e-3) == (a-2*PI))
+    self.assertTrue(Approx(Vector(translation),1e-3) == T)
+
+if __name__ ==  '__main__':
+  unittest.main()

codac4matlab/unsupported/__init__.py

@@ -0,0 +1 @@
+from codac4matlab._unsupported import *

codac4matlab/version.py

@@ -0,0 +1 @@
+__version__="2.0.0"

codac4matlab-2.0.0.dev14.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: codac4matlab
+Version: 2.0.0.dev14
+Summary: Codac is a library providing tools for constraint programming over reals and trajectories.
+Home-page: http://codac.io
+Author: Simon Rohou, Benoit Desrochers, Fabrice Le Bars
+Author-email: simon.rohou@ensta.fr
+License: LGPLv3+
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Requires-Dist: pip>=19.0.0
+Requires-Dist: vibes
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+Codac is a library providing tools for constraint programming over reals and trajectories.

codac4matlab-2.0.0.dev14.dist-info/RECORD

@@ -0,0 +1,61 @@
+codac4matlab/__init__.py,sha256=r-pCygYV4CF5tKiia4HNtmZoAOSRYgexPuKEKSPUcd0,142
+codac4matlab/_core.cp313-win32.pyd,sha256=rqKgkX4IXn0PiQDrIIuPlL8LJSyV5gCRJsXSJs_qMMg,5288960
+codac4matlab/_graphics.cp313-win32.pyd,sha256=YbZAZnItB7_iPDCJicLtugJwZeHyYeEidDxVAyTjTM8,1075712
+codac4matlab/_unsupported.cp313-win32.pyd,sha256=USlsNL8uKcfgLgiWncS_R4s7eAKjiEBljXa_80BBBE0,110592
+codac4matlab/version.py,sha256=6aTsaEKyBHFdzQjDU6jvkF0BXPK1486LAfHKk-VQHKc,19
+codac4matlab/core/__init__.py,sha256=Ykq7hulUGDJtFs5vXg-BjxVgu6Qp4H4EdCmiAb7sNv0,10491
+codac4matlab/graphics/__init__.py,sha256=JhVtofKJJLBAFAJOy3ecPPjlyk4eXgVmGHCK9ZOT7NE,36
+codac4matlab/tests/__init__.py,sha256=p2nc-vz1OyekHP7d82yXsE2hNAtyHREmhuKHBZDS4dg,67
+codac4matlab/tests/test_AnalyticFunction.py,sha256=7RRE5TVxibOJSvOhE8sltONLM0V4NAyL3epCE-EBeHA,21919
+codac4matlab/tests/test_AnalyticTraj.py,sha256=kdeWN85YLHbFRkGHzubsYR_J6-H7tSwmjCV2701UW_U,2454
+codac4matlab/tests/test_Approx.py,sha256=SoJWfJ-ErmDnd5bot-tetiwSDDu6ZtPGaqzEC10pOA0,934
+codac4matlab/tests/test_BoolInterval.py,sha256=NTBtQqXl2ZR6YUXsIYWSrYeKrSulAqsoWaYVOPTadec,2184
+codac4matlab/tests/test_Color.py,sha256=BwMGjM4b1AIa7tuLUWExN9Oszamcv9_sRe5ZgkX7qE4,2551
+codac4matlab/tests/test_ConvexPolygon.py,sha256=r4e0iYV2OoCsCR2OudrDzmPfK3VCBvBtYvyHqVNEpV0,7597
+codac4matlab/tests/test_CtcAction.py,sha256=kdri7lzbw_WUV3WuUVG45BgM7NfKpSDHw6-Erd65iQU,811
+codac4matlab/tests/test_CtcCartProd.py,sha256=tm9ljT5YyFiKh88cN7c10EKU4qGtJ8ErOztxZVK3fYM,1080
+codac4matlab/tests/test_CtcCtcBoundary.py,sha256=xg-ppWNJLTGrQOY2hPk75sfWCuV1jSUmVpjZUSqtUv8,1609
+codac4matlab/tests/test_CtcFixpoint.py,sha256=zsA-c7chkGI-FpyP-IG7MGikZf5fg-PRiMj2CHMnO_o,2027
+codac4matlab/tests/test_CtcInter.py,sha256=z_51zQ4pOEWKnSkfPBhEh5gV0LuAsAb4wLRq-39yw5o,1017
+codac4matlab/tests/test_CtcInverse.py,sha256=aNTPdfvg7eklZ3cgTBbfE5YlSBYWF74pNkJyMKAJ5A0,5055
+codac4matlab/tests/test_CtcInverseNotIn.py,sha256=PsG_i0qOf8e1c5zribWgLTJlVyt8EnHkKjisU0PKq64,4314
+codac4matlab/tests/test_CtcLazy.py,sha256=Pix60QnocuggEU7jhCTbKQa_85njlEZSekzPdrXQJaE,1391
+codac4matlab/tests/test_CtcPolygon.py,sha256=SYU1Dd32Erh_I2fRbgMehVlQEOFoIQB5_DVwjADP2OQ,2287
+codac4matlab/tests/test_CtcSegment.py,sha256=p7YJTtyhVegZhAZV3c9gTEDl-Djak0z95u33Fdr1sWk,2779
+codac4matlab/tests/test_Ellipsoid.py,sha256=mEfrDI14hwj_ormNlyjz-5BglLXs9R8ubgQZh34Qzg0,483
+codac4matlab/tests/test_IntFullPivLU.py,sha256=YWvb2k9sw8dh42dMIwqOpp2FwEyUqwMTSBTWLUJs9W4,1769
+codac4matlab/tests/test_Interval.py,sha256=W2jIft8UkIHVnzlFLy-n8aV07LzfreU8y5S68v0-sT8,10028
+codac4matlab/tests/test_IntervalMatrix.py,sha256=p7gqJNjzqFDZCfTcvjb5j3vEdb1uzevrYK_z-FhRb8Y,17676
+codac4matlab/tests/test_IntervalVector.py,sha256=IsRJEHZBuzvndoSRRH0l6cG9-0oA4LAECvpghZT55eU,22167
+codac4matlab/tests/test_Interval_operations.py,sha256=Rq9aQ79CNarnT0KVn_0dGOWidXfGf-LHB1SXARv036c,15513
+codac4matlab/tests/test_Matrix.py,sha256=dZdgIiRTI-QJWCxfe1tVUDeC6pkj7PKPcFl22lJ5BXw,1250
+codac4matlab/tests/test_OctaSym.py,sha256=Q_y1QTNbnGfRLTpi-9aElsdvwV5by51rdWsyZO5gcdc,895
+codac4matlab/tests/test_Polygon.py,sha256=yq_laPgY0jIAj1UHT2T4WwrNff9XRmo9hyNh25gKyLw,4807
+codac4matlab/tests/test_SampledTraj.py,sha256=PvuR5qxeL6M7qYue-1isQBls1q6rc2UlyzO0FUtyK0w,3405
+codac4matlab/tests/test_Segment.py,sha256=M7jaUioE3ETEXfqle6IpyYQ4_aMSQ_lUEKM-WwqBt2M,6721
+codac4matlab/tests/test_SepCartProd.py,sha256=TSNgyfdGNgL_IHGtospr1ziLIguYcBNk8RUMY5uBl40,1073
+codac4matlab/tests/test_SepCtcBoundary.py,sha256=Eq-bpRkE6StgSryHWKpCcB_oc4_EhNox2ACqS_N8TNc,1841
+codac4matlab/tests/test_SepInverse.py,sha256=ophcxXmsz_098c8HObBU2qbsSDqKDfKhh5B8b-iby0g,3500
+codac4matlab/tests/test_SepPolygon.py,sha256=IOgUNJB9EQ09y338sQq7WXIkc_3FBWCGlaj11veskk4,2780
+codac4matlab/tests/test_SepProj.py,sha256=TuIjTGLsOeg3lsx_kySdIT8omaiSWreJJLfSwN81YiY,1284
+codac4matlab/tests/test_SepTransform.py,sha256=hD_F2axo6uSq8_E9nTnU9NRv2Hy_d1PQ281kuLiUs68,1425
+codac4matlab/tests/test_Vector.py,sha256=D3Kz8mdZFOvdfTuRqe780BwdYWFJ5roUHCyWMdGRUXU,928
+codac4matlab/tests/test_arithmetic_add.py,sha256=zVcHgrrF-hqLyycDQQ3P0bWC13t5ci-ry_Z_mHztGf8,3834
+codac4matlab/tests/test_arithmetic_div.py,sha256=euBbRVeU1ec5IvxcIthQ3R4gGwIlynmJAGldBz5wYII,2362
+codac4matlab/tests/test_arithmetic_mul.py,sha256=fgD3NDlJiF8jEC8bhXJCRIMGR3fkknWliQrm_GwPNXI,8020
+codac4matlab/tests/test_arithmetic_sub.py,sha256=b4YHE5Zh2pWkQamF-LA3kFQmMrY24YuG44xCNzjFj68,3886
+codac4matlab/tests/test_capd.py,sha256=GoC6zzah0XZ1JjuQlfeSUlXf0i2LYwct09g0G9MgbFk,451
+codac4matlab/tests/test_cart_prod.py,sha256=2Boh-vsxmqwxis83VTmpiL6MwBE8zeO4F5DxwNcejwU,1692
+codac4matlab/tests/test_eigen.py,sha256=QeCe6RHPnCZCiCv_ap0tnSzhl7AT_dSe9MZsOCbUqS0,452
+codac4matlab/tests/test_geometry.py,sha256=82nOVO2-vPwjR1ZYCKUqCL59iHVGsA5sLsbgNxX7S3E,5885
+codac4matlab/tests/test_hull.py,sha256=z21u9wvlK5igijQBUlUaIyfPViPpeV4SFnm5BgoJM88,1574
+codac4matlab/tests/test_ibex.py,sha256=EUmtn72dyyLwoHHi04mph0a2Ud-_M3JVzmBkwUCNHXg,484
+codac4matlab/tests/test_inversion.py,sha256=iY8dE4ik-4baVdHt3CvOHWXiOlJCbYu4oDZU9w2NOQw,1273
+codac4matlab/tests/test_linear_ctc.py,sha256=2KPiRlVF1_Diy-zfmLqZj9sJdu7esRFE7HpCU0Xj3Mc,2336
+codac4matlab/tests/test_operators.py,sha256=UmXAJx3HQtb_TLJ0Msy5MXoitrXvdQb1OqEuKfaorAY,22363
+codac4matlab/tests/test_transformations.py,sha256=5-ZdSHSBYvV3WesAa-6ikSFDwWf7mAz5Cqb-3OiU0WE,1788
+codac4matlab/unsupported/__init__.py,sha256=z5Xm26-xg1FntpomMqRsqcyqAI8y8C4Db9FMtfx4skI,39
+codac4matlab-2.0.0.dev14.dist-info/METADATA,sha256=owekbvkAdko9gN2yNA2Cx7O8Zm4V_ecf3YaY7Fv1VNg,813
+codac4matlab-2.0.0.dev14.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+codac4matlab-2.0.0.dev14.dist-info/top_level.txt,sha256=ZeLeS-8xPyH0yVFjcLqUgqnqV4umnaerrPV-cSX1c_U,13
+codac4matlab-2.0.0.dev14.dist-info/RECORD,,

codac4matlab-2.0.0.dev14.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.3.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codac4matlab-2.0.0.dev14.dist-info/top_level.txt

@@ -0,0 +1 @@
+codac4matlab