def test_CtcSegment02(self):
c = CtcSegment(0, 0, 10, 20)
box = IntervalVector([[10, 50], [20, 50]])
resbox = IntervalVector([[10, 10], [20, 20]])
c.contract(box)
self.assertEqual(box, resbox)
def test_subvector(self):
a = IntervalVector(list(range(0, 10)))
self.assertEqual(len(a), 10)
b = a.subvector(3, 6)
self.assertEqual(len(b), 4)
b[0] = Interval(-2, 3)
self.assertEqual(b[0], Interval(-2, 3))
def test_singleton_variables_double_or_Vector_2(self):
x = Interval(0, 1)
y = Interval(-2, 3)
a = Interval(1, 20)
vector_y = [2, 1.]
ivx = IntervalVector(2, x)
iva = IntervalVector(2, a)
ctc_add = CtcFunction(Function("b", "c", "a", "b+c-a"))
cn = ContractorNetwork()
cn.add(ctc_add, [ivx, vector_y, iva])
cn.add(ctc_add, [ivx, vector_y, iva]) # redundant adding
cn.add(ctc_add, [ivx, vector_y, iva]) # redundant adding
cn.contract()
self.assertEqual(ivx, IntervalVector(2, [0, 1]))
self.assertEqual(vector_y, [2, 1.])
self.assertEqual(iva, IntervalVector([[2, 3], [1, 2]]))
#self.assertEqual(cn.nb_dom(), 3*3) # todo: not able to get reference from a py::list
#self.assertEqual(cn.nb_ctc(), 3+2) # todo: not able to get reference from a py::list
cn.set_name(vector_y, "y")
cn.set_name(ivx, "x")
cn.set_name(iva, "a")
cn.set_name(ctc_add, "+")
cn.print_dot_graph("cn_singleton")
def test_contract_degenerate(self):
c = CtcSegment(5, 5, 5, 5)
box = IntervalVector([[-5, 50], [-5, 50]])
resbox = IntervalVector([[5, 5], [5, 5]])
c.contract(box)
self.assertEqual(box, resbox)
def test_contract_empty(self):
c = CtcSegment(0, 0, 10, 20)
box = IntervalVector([[-5, -2], [-5, 50]])
resbox = IntervalVector.empty(2)
c.contract(box)
self.assertEqual(box, resbox)
def test_dependencies_on_vector_components_1(self):
x = Interval(0, 1)
y = Interval(-2, 3)
a = Interval(1, 20)
vx = IntervalVector(2, x)
vy = IntervalVector(2, y)
va = IntervalVector(2, a)
vec = [4, 0.5]
ctc_add = CtcFunction(Function("b", "c", "a", "b+c-a"))
ctc_cos = CtcFunction(Function("b", "c", "a", "b+c-a"))
ctc_minus = CtcFunction(Function("b", "c", "b-c-0"))
cn = ContractorNetwork()
cn.add(ctc_add, [x, y, a])
cn.add(ctc_add, [x, y, a])
cn.contract()
self.assertEqual(x, Interval(0, 1))
self.assertEqual(y, Interval(0, 3))
self.assertEqual(a, Interval(1, 4))
self.assertEqual(cn.nb_dom(), 3)
self.assertEqual(cn.nb_ctc(), 1)
def test_call_with_empty_box(self):
c = CtcSegment(0, 0, 10, 20)
box = IntervalVector(2, Interval.ALL_REALS)
resbox = IntervalVector([[0, 10], [0, 20]])
c.contract(box)
self.assertEqual(box, resbox)
def test_ops_4(self):
a = IntervalVector(2, Interval(-1, 1))
b = IntervalVector(2, Interval(-3, 1))
self.assertEqual(a * b, Interval(-6, 6))
self.assertEqual(3 * a, IntervalVector(2, Interval(-3, 3)))
self.assertEqual(a * [2, 2], Interval(-4, 4))
self.assertEqual(
Interval(2, 3) * a, IntervalVector(2, Interval(-3, 3)))
def test_put(self):
a = IntervalVector(list(range(0, 10)))
self.assertEqual(len(a), 10)
a.put(3, IntervalVector([1, 2, 3]))
self.assertEqual(a[3], Interval(1))
self.assertEqual(a[4], Interval(2))
self.assertEqual(a[5], Interval(3))
self.assertEqual(a[6], Interval(6))
def __init__(self, Xin, Xout=None):
"""Constructor."""
self.xin = IntervalVector(Xin)
self.xout = IntervalVector(Xin) if (Xout is None) else Xout
self.left = None
self.right = None
self.X0 = None
self.X = None
def test_TubeVector(self):
# modif Interval -> IntervalVector
tube = TubeVector(Interval(0., 1.), IntervalVector(1, [-1., 1.]))
self.assertEqual(tube.tdomain(), Interval(0., 1.))
self.assertEqual(tube.codomain(), IntervalVector(1, [-1., 1.]))
tube_copy1 = tube
self.assertEqual(tube_copy1.tdomain(), Interval(0., 1.))
self.assertEqual(tube_copy1.codomain(), IntervalVector(1, [-1., 1.]))
self.assertEqual(tube_copy1, tube)
def test_SepPolarXY_01(self):
x = hex2Itv('-0x1.9032ae28d8664p+4', '-0x1.9032ae28d8664p+4')
y = hex2Itv('-0x1.68d6cf2e8c8b8p+0', '-0x1.68d6cf2e8c8b8p+0')
rho = Interval(25.0607, 25.1231)
theta = Interval(-3.14159, -2.79253)
S = SepPolarXY(rho, theta)
xin, xout = IntervalVector([x, y]), IntervalVector([x, y])
S.separate(xin, xout)
self.assertTrue(xout.is_empty())
self.assertEqual(xin, IntervalVector([x, y]))
def test_SepPolarXY_02(self):
rho = hex2Itv('0x1.b9adea897635fp+2', '0x1.c01450efdc9c5p+2')
theta = hex2Itv('-0x1.95b92733b853ep+2', '-0x1.690af69de9cacp+2')
S = SepPolarXY(rho, theta)
X = IntervalVector(2)
X[0] = hex2Itv('0x1.be002da3cfcc6p+2', '0x1.be002da3cfcc6p+2')
X[1] = hex2Itv('-0x1.32b8f5d87284bp-2', '-0x1.32b8f5d87284bp-2')
xin, xout = X.copy(), X.copy()
S.separate(xin, xout)
self.assertFalse(xin.is_empty() and xout.is_empty())
def read(cls, stream):
size, = struct.unpack("<i", stream.read(struct.calcsize("<i")))
fmt = "d" * 2 * size
bounds_in = struct.unpack(fmt, stream.read(struct.calcsize(fmt)))
bounds_out = struct.unpack(fmt, stream.read(struct.calcsize(fmt)))
is_leaf, = struct.unpack("?", stream.read(struct.calcsize("?")))
bounds_in = [list(bounds_in[2 * i:2 * (i + 1)]) for i in range(size)]
bounds_out = [list(bounds_out[2 * i:2 * (i + 1)]) for i in range(size)]
node = pySetNode(IntervalVector(bounds_in), IntervalVector(bounds_out))
if not is_leaf:
node.left = cls.read(stream)
node.right = cls.read(stream)
return node
def test_contract_empty(self):
c = CtcSegment(0,0,10,20);
box = IntervalVector([[-5,-2], [-5,50]]);
resbox = IntervalVector.empty(2);
c.contract(box);
self.assertEqual(box , resbox)
def test_subvector(self):
x = IntervalVector([[0, 1], [-2, 3], [1, 20]])
ctc_add = CtcFunction(Function("b", "c", "a", "b+c-a"))
cn = ContractorNetwork()
sub_x = cn.subvector(x, 1, 2)
self.assertEqual(sub_x[0], Interval(-2, 3))
self.assertEqual(sub_x[1], Interval(1, 20))
cn.add(ctc_add, [x[0], x[1], x[2]])
cn.contract()
self.assertEqual(x[0], Interval(0, 1))
self.assertEqual(x[1], Interval(0, 3))
self.assertEqual(x[2], Interval(1, 4))
self.assertEqual(sub_x[0], Interval(0, 3))
self.assertEqual(sub_x[1], Interval(1, 4))
sub_x[0] = Interval(1, 2)
cn.trigger_all_contractors()
cn.contract()
self.assertEqual(x[1], Interval(1, 2))
def separate(self, xin, xout):
X0 = xin | xout
X = xin & xout
stack = deque([self.root])
k = 0
xborder = IntervalVector.empty(xin.size())
while len(stack) > 0:
n = stack.popleft()
k = k + 1
nX = (n.xin & n.xout)
if n.isLeaf():
xborder |= (X & nX)
else:
Xleft = n.left.getX() & X
Xright = n.right.getX() & X
if not Xleft.is_empty() and not Xleft.is_subset(xborder):
stack.append(n.left)
if not Xright.is_empty() and not Xright.is_subset(xborder):
stack.append(n.right)
xin &= xborder
xout &= xborder
for b in X0.diff(xborder):
isInside = self.root.isInside(b.mid())
if isInside is True:
xout |= b
elif isInside is False:
xin |= b
else:
xin |= b
xout |= b
print(k)
def test_is_bisectable(self):
a = IntervalVector(2, Interval(-2, 4))
self.assertTrue(a.is_bisectable())
b = IntervalVector(2, Interval(1, 3))
self.assertTrue(b.is_bisectable())
b[0] = Interval(0)
self.assertTrue(b.is_bisectable())
b[1] = Interval(0)
self.assertFalse(b.is_bisectable())
def test_dependencies_on_vector_components(self):
ctc_plus = CtcFunction(Function("a", "b", "c",
"a+b-c")) # algebraic constraint a+b=c
a = IntervalVector(2, [0, 1])
b = IntervalVector(2, [-1, 1])
c = IntervalVector(2, [1.5, 2])
d = IntervalVector(2, [0., 0.])
e = IntervalVectore(2)
cn = ContractorNetwork()
# Contractors are added to the graph,
# the first one contracts the vector sets, the second one then contracts the components intervals,
# and so it should trigger again the first one since components have changed.
cn.add(ctc_plus, [b, d, e])
cn.add(ctc_plus, [b, d, e])
cn.add(ctc_plus, [b, d, e])
cn.add(ctc_plus, [a[0], b[0], c[0]])
cn.add(ctc_plus, [a[0], b[0], c[0]])
cn.add(ctc_plus, [a[0], b[0], c[0]])
cn.add(ctc_plus, [a[0], b[0], c[0]])
cn.contract()
self.assertEqual(a[0], Interval(0.5, 1))
self.assertEqual(b[0], Interval(0.5, 1))
self.assertEqual(c[0], Interval(1.5, 2))
self.assertEqual(d[0], Interval(0))
self.assertEqual(e[0], Interval(0.5, 1))
# Before setting names (some vectors not added entirely):
self.assertEqual(cn.nb_dom(), 3 * 3 + 2)
# vector items contractors + ctc_plus in array mode + ctc_plus on scalar values
self.assertEqual(cn.nb_ctc(), 3 + 2 + 1)
cn.set_name(a, "a")
cn.set_name(b, "b")
cn.set_name(c, "c")
cn.set_name(d, "d")
cn.set_name(e, "e")
cn.set_name(ctc_plus, "+")
cn.print_dot_graph("cn_vector_dependencies")
self.assertEqual(cn.nb_dom(), 3 * 5)
# vector items contractors + ctc_plus in array mode + ctc_plus on scalar values
self.assertEqual(cn.nb_ctc(), 5 + 2 + 1)
def test_pickling(self):
p = IntervalVector(
[Interval(0, 5),
Interval(0, oo), Interval.EMPTY_SET])
data = pickle.dumps(p, 2) # Must use pickle protocol >= 2
p2 = pickle.loads(data)
self.assertEqual(p, p2)
def test_ops_2(self):
a = IntervalVector(2, Interval(-1, 1))
b = IntervalVector(2, Interval(-3, 1))
a += b
self.assertEqual(a, IntervalVector(2, Interval(-4, 2)))
a = IntervalVector(2, Interval(-1, 1))
a -= b
self.assertEqual(a, IntervalVector(2, Interval(-2, 4)))
a = IntervalVector(2, Interval(-1, 1))
a &= b
self.assertEqual(a, IntervalVector(2, Interval(-1, 1)))
a = IntervalVector(2, Interval(-1, 1))
a |= b
self.assertEqual(a, IntervalVector(2, Interval(-3, 1)))
def __pySIVIA_ctc(X0,
ctc,
epsilon,
color_out='k[b]',
color_maybe='k[y]',
draw_boxes=True,
save_result=True,
**kwargs):
stack = deque([IntervalVector(X0)])
res_y, res_out = [], []
lf = LargestFirst(epsilon / 2.0)
k = 0
while len(stack) > 0:
k = k + 1
X = stack.popleft()
X0 = IntervalVector(X)
# X = __contract_and_extract(X, ctc, res_out, color_out)
ctc.contract(X)
if (draw_boxes is True and vibes_available is True):
drawBoxDiff(X0, X, color_out, **kwargs)
if save_result is True:
res_out += X0.diff(X)
if (X.is_empty()):
continue
if (X.max_diam() < epsilon):
if draw_boxes is True:
vibes.drawBox(X[0].lb(), X[0].ub(), X[1].lb(), X[1].ub(),
color_maybe)
if save_result is True:
res_y.append(X)
elif (X.is_empty() is False):
(X1, X2) = lf.bisect(X)
stack.append(X1)
stack.append(X2)
print('number of contraction %d / number of boxes %d' %
(k, len(res_out) + len(res_y)))
return (res_out, res_y)
def test_simple_static_case(self):
ctc_plus = CtcFunction(Function("a", "b", "c",
"a+b-c")) # algebraic constraint a+b=c
a = IntervalVector(2, [0, 1])
b = IntervalVector(2, [-1, 1])
c = IntervalVector(2, [1.5, 2])
cn = ContractorNetwork()
cn.add(ctc_plus, [a[0], b[0], c[0]])
cn.contract()
self.assertEqual(a[0], Interval(0.5, 1))
self.assertEqual(b[0], Interval(0.5, 1))
self.assertEqual(c[0], Interval(1.5, 2))
self.assertEqual(cn.nb_dom(), 3)
self.assertEqual(cn.nb_ctc(), 1)
def test_gettiem2(self):
"""
check if gettiem returns a non constant reference on an Interval
"""
c = IntervalVector((1, 2, 3))
b = c[1]
self.assertEqual(b, Interval(2))
c[1] = Interval(-1, 2)
self.assertEqual(c[1], Interval(-1, 2))
self.assertEqual(b, Interval(-1, 2))
def setUp(self):
tdomain = Interval(0., 10.)
dt = 0.1
self.x = TubeVector(tdomain, dt, 3)
self.y = TubeVector(self.x)
self.z = TubeVector(self.x)
# TrajectoryVector trajx(3), trajy(3)
# IntervalVector ix(3), iy(3)
self.a0, self.a1, self.a2 = Interval(1.), Interval(2.), Interval(3.)
self.b0, self.b1, self.b2 = Interval(0.), Interval(10.), Interval(20.)
self.ix = IntervalVector([self.a0, self.a1, self.a2])
self.iy = IntervalVector([self.b0, self.b1, self.b2])
# ix[0] = a0 ix[1] = a1 ix[2] = a2
# iy[0] = b0 iy[1] = b1 iy[2] = b2
self.x.set(self.ix)
self.y.set(self.iy)
def test_SIVIA(self):
l = [[-1, 1, 0], [-1, -2, 1]]
sep = SepPolygon(l)
f = Function('x', 'y', '(2*x-y, 2*y - x)')
finv = Function('x', 'y', '(1/3.0*(2*x+y),1/3.0*(2*y+x))')
# sepInv = SepInverse(sep, f)
# sepTrans = SepTransform(sep, f, finv)
Xin = IntervalVector(2, Interval(-10, 10))
Xout = IntervalVector(2, Interval(-10, 10))
eps = 0.05
# sep.separate(Xin, Xout)
pySIVIA(
Xin,
sep,
eps,
figureName='Sep',
draw_boxes=False,
)
def test_dependencies_on_vector_components_2(self):
x = Interval(0, 1)
y = Interval(-2, 3)
a = Interval(1, 20)
vx = IntervalVector(2, x)
vy = IntervalVector(2, y)
va = IntervalVector(2, a)
vec = [4, 0.5]
ctc_add = CtcFunction(Function("b", "c", "a", "b+c-a"))
ctc_cos = CtcFunction(Function("b", "c", "a", "b+c-a"))
cn = ContractorNetwork()
cn.add(ctc_add, [vx, vy, va])
cn.add(ctc_add, [vx[0], vy[0], va[0]])
cn.contract()
self.assertEqual(vx, IntervalVector(2, [0, 1]))
self.assertEqual(vy, IntervalVector(2, [0, 3]))
self.assertEqual(va, IntervalVector(2, [1, 4]))
self.assertEqual(cn.nb_dom(), 3 * 3)
self.assertEqual(cn.nb_ctc(), 3 + 2)
cn.set_name(va, "a")
cn.set_name(vx, "x")
cn.set_name(vy, "y")
cn.print_dot_graph("cn_function")
def test_TubeClasss(self):
box1 = IntervalVector(2)
box2 = IntervalVector(2)
box3 = IntervalVector(2)
box4 = IntervalVector(2)
box1[0] = Interval(-1., 10.)
box1[1] = Interval(3., 4.)
box2[0] = Interval(10., 10.5)
box2[1] = Interval(2., 7.)
box3[0] = Interval(10.5, 12.)
box3[1] = Interval(5., 6.)
box4[0] = Interval(12., 14.)
box4[1] = Interval(5.5)
v_tdomains = [box1[0], box2[0], box3[0], box4[0]]
v_codomains = [box1[1], box2[1], box3[1], box4[1]]
tube_from_boxes = Tube(v_tdomains, v_codomains)
self.assertEqual(tube_from_boxes.tdomain(), Interval(-1., 14.))
self.assertEqual(tube_from_boxes.codomain(), Interval(2., 7.))
self.assertEqual(tube_from_boxes.nb_slices(), 4)
self.assertEqual(tube_from_boxes(0), Interval(3., 4.))
self.assertEqual(tube_from_boxes(1), Interval(2., 7.))
self.assertEqual(tube_from_boxes(2), Interval(5., 6.))
self.assertEqual(tube_from_boxes(3), Interval(5.5))
self.assertEqual(
tube_from_boxes.slice(0).tdomain(), Interval(-1., 10.))
self.assertEqual(
tube_from_boxes.slice(1).tdomain(), Interval(10., 10.5))
self.assertEqual(
tube_from_boxes.slice(2).tdomain(), Interval(10.5, 12.))
self.assertEqual(
tube_from_boxes.slice(3).tdomain(), Interval(12., 14.))
def test_ops_plus(self):
a = IntervalVector(2, Interval(-1, 1))
b = IntervalVector(2, Interval(-3, 1))
self.assertEqual(a + b, IntervalVector(2, Interval(-4, 2)))
self.assertEqual(a - b, IntervalVector(2, Interval(-2, 4)))
self.assertEqual(a & b, IntervalVector(2, Interval(-1, 1)))
self.assertEqual(a | b, IntervalVector(2, Interval(-3, 1)))
self.assertTrue(a != b)
def test_CtcFunction_on_heterogeneous_variables(self):
x = IntervalVector([[0, 1], [-2, 3]])
a = Interval(1, 20)
ctc_add = CtcFunction(Function("b[2]", "a", "b[0]+b[1]-a"))
cn = ContractorNetwork()
cn.add(ctc_add, [x, a])
cn.contract()
self.assertEqual(x[0], Interval(0, 1))
self.assertEqual(x[1], Interval(0, 3))
self.assertEqual(a, Interval(1, 4))
def test_ops_3(self):
a = IntervalVector(2, Interval(-1, 1))
a += [2, 2]
self.assertEqual(a, IntervalVector(2, Interval(1, 3)))
a = IntervalVector(2, Interval(-1, 1))
a -= [2, 2]
self.assertEqual(a, IntervalVector(2, Interval(-3, -1)))
a = IntervalVector(2, Interval(-1, 1))
a *= Interval(2, 3)
self.assertEqual(a, IntervalVector(2, Interval(-3, 3)))
a = IntervalVector(2, Interval(-1, 1))
a *= 3.0
self.assertEqual(a, IntervalVector(2, Interval(-3, 3)))