def test_sparse():
sparse_array = MutableSparseNDimArray([0, 0, 0, 1], (2, 2))
assert len(sparse_array) == 2 * 2
# dictionary where all data is, only non-zero entries are actually stored:
assert len(sparse_array._sparse_array) == 1
assert list(sparse_array) == [0, 0, 0, 1]
for i, j in zip(sparse_array, [0, 0, 0, 1]):
assert i == j
sparse_array[0, 0] = 123
assert len(sparse_array._sparse_array) == 2
assert sparse_array[0, 0] == 123
# when element in sparse array become zero it will disappear from
# dictionary
sparse_array[0, 0] = 0
assert len(sparse_array._sparse_array) == 1
sparse_array[1, 1] = 0
assert len(sparse_array._sparse_array) == 0
assert sparse_array[0, 0] == 0
# test for large scale sparse array
a = MutableSparseNDimArray.zeros(100000, 200000)
b = MutableSparseNDimArray.zeros(100000, 200000)
assert a == b
a[1, 1] = 1
b[1, 1] = 2
assert a != b
def test_ndim_array_converting():
dense_array = MutableDenseNDimArray([1, 2, 3, 4], (2, 2))
alist = dense_array.tolist()
alist == [[1, 2], [3, 4]]
matrix = dense_array.tomatrix()
assert (isinstance(matrix, Matrix))
for i in range(len(dense_array)):
assert dense_array[i] == matrix[i]
assert matrix.shape == dense_array.shape
assert MutableDenseNDimArray(matrix) == dense_array
assert MutableDenseNDimArray(matrix.as_immutable()) == dense_array
assert MutableDenseNDimArray(matrix.as_mutable()) == dense_array
sparse_array = MutableSparseNDimArray([1, 2, 3, 4], (2, 2))
alist = sparse_array.tolist()
assert alist == [[1, 2], [3, 4]]
matrix = sparse_array.tomatrix()
assert(isinstance(matrix, SparseMatrix))
for i in range(len(sparse_array)):
assert sparse_array[i] == matrix[i]
assert matrix.shape == sparse_array.shape
assert MutableSparseNDimArray(matrix) == sparse_array
assert MutableSparseNDimArray(matrix.as_immutable()) == sparse_array
assert MutableSparseNDimArray(matrix.as_mutable()) == sparse_array
def test_diff():
from sympy.abc import x, y, z
md = MutableDenseNDimArray([[x, y], [x*z, x*y*z]])
assert md.diff(x) == MutableDenseNDimArray([[1, 0], [z, y*z]])
sd = MutableSparseNDimArray(md)
assert sd == MutableSparseNDimArray([x, y, x*z, x*y*z], (2, 2))
assert sd.diff(x) == MutableSparseNDimArray([[1, 0], [z, y*z]])
def test_diff():
from sympy.abc import x, y, z
md = MutableDenseNDimArray([[x, y], [x * z, x * y * z]])
assert md.diff(x) == MutableDenseNDimArray([[1, 0], [z, y * z]])
sd = MutableSparseNDimArray(md)
assert sd == MutableSparseNDimArray([x, y, x * z, x * y * z], (2, 2))
assert sd.diff(x) == MutableSparseNDimArray([[1, 0], [z, y * z]])
def test_ndim_array_initiation():
arr_with_one_element = MutableDenseNDimArray([23])
assert len(arr_with_one_element) == 1
assert arr_with_one_element[0] == 23
assert arr_with_one_element.rank() == 1
raises(ValueError, lambda: arr_with_one_element[1])
arr_with_symbol_element = MutableDenseNDimArray([Symbol('x')])
assert len(arr_with_symbol_element) == 1
assert arr_with_symbol_element[0] == Symbol('x')
assert arr_with_symbol_element.rank() == 1
number5 = 5
vector = MutableDenseNDimArray.zeros(number5)
assert len(vector) == number5
assert vector.shape == (number5,)
assert vector.rank() == 1
raises(ValueError, lambda: arr_with_one_element[5])
vector = MutableSparseNDimArray.zeros(number5)
assert len(vector) == number5
assert vector.shape == (number5,)
assert vector._sparse_array == {}
assert vector.rank() == 1
n_dim_array = MutableDenseNDimArray(range(3**4), (3, 3, 3, 3,))
assert len(n_dim_array) == 3 * 3 * 3 * 3
assert n_dim_array.shape == (3, 3, 3, 3)
assert n_dim_array.rank() == 4
raises(ValueError, lambda: n_dim_array[0, 0, 0, 3])
raises(ValueError, lambda: n_dim_array[3, 0, 0, 0])
raises(ValueError, lambda: n_dim_array[3**4])
array_shape = (3, 3, 3, 3)
sparse_array = MutableSparseNDimArray.zeros(*array_shape)
assert len(sparse_array._sparse_array) == 0
assert len(sparse_array) == 3 * 3 * 3 * 3
assert n_dim_array.shape == array_shape
assert n_dim_array.rank() == 4
one_dim_array = MutableDenseNDimArray([2, 3, 1])
assert len(one_dim_array) == 3
assert one_dim_array.shape == (3,)
assert one_dim_array.rank() == 1
assert one_dim_array.tolist() == [2, 3, 1]
shape = (3, 3)
array_with_many_args = MutableSparseNDimArray.zeros(*shape)
assert len(array_with_many_args) == 3 * 3
assert array_with_many_args.shape == shape
assert array_with_many_args[0, 0] == 0
assert array_with_many_args.rank() == 2
def test_ndim_array_converting():
dense_array = MutableDenseNDimArray([1, 2, 3, 4], (2, 2))
alist = dense_array.tolist()
alist == [[1, 2], [3, 4]]
matrix = dense_array.tomatrix()
assert (isinstance(matrix, Matrix))
for i in range(len(dense_array)):
assert dense_array[dense_array._get_tuple_index(i)] == matrix[i]
assert matrix.shape == dense_array.shape
assert MutableDenseNDimArray(matrix) == dense_array
assert MutableDenseNDimArray(matrix.as_immutable()) == dense_array
assert MutableDenseNDimArray(matrix.as_mutable()) == dense_array
sparse_array = MutableSparseNDimArray([1, 2, 3, 4], (2, 2))
alist = sparse_array.tolist()
assert alist == [[1, 2], [3, 4]]
matrix = sparse_array.tomatrix()
assert (isinstance(matrix, SparseMatrix))
for i in range(len(sparse_array)):
assert sparse_array[sparse_array._get_tuple_index(i)] == matrix[i]
assert matrix.shape == sparse_array.shape
assert MutableSparseNDimArray(matrix) == sparse_array
assert MutableSparseNDimArray(matrix.as_immutable()) == sparse_array
assert MutableSparseNDimArray(matrix.as_mutable()) == sparse_array
def test_sparse():
sparse_array = MutableSparseNDimArray([0, 0, 0, 1], (2, 2))
assert len(sparse_array) == 2 * 2
# dictionary where all data is, only non-zero entries are actually stored:
assert len(sparse_array._sparse_array) == 1
assert list(sparse_array) == [0, 0, 0, 1]
for i, j in zip(sparse_array, [0, 0, 0, 1]):
assert i == j
sparse_array[0, 0] = 123
assert len(sparse_array._sparse_array) == 2
assert sparse_array[0, 0] == 123
assert sparse_array / 0 == MutableSparseNDimArray(
[[S.ComplexInfinity, S.NaN], [S.NaN, S.ComplexInfinity]], (2, 2))
# when element in sparse array become zero it will disappear from
# dictionary
sparse_array[0, 0] = 0
assert len(sparse_array._sparse_array) == 1
sparse_array[1, 1] = 0
assert len(sparse_array._sparse_array) == 0
assert sparse_array[0, 0] == 0
# test for large scale sparse array
# equality test
a = MutableSparseNDimArray.zeros(100000, 200000)
b = MutableSparseNDimArray.zeros(100000, 200000)
assert a == b
a[1, 1] = 1
b[1, 1] = 2
assert a != b
# __mul__ and __rmul__
assert a * 3 == MutableSparseNDimArray({200001: 3}, (100000, 200000))
assert 3 * a == MutableSparseNDimArray({200001: 3}, (100000, 200000))
assert a * 0 == MutableSparseNDimArray({}, (100000, 200000))
assert 0 * a == MutableSparseNDimArray({}, (100000, 200000))
# __div__
assert a / 3 == MutableSparseNDimArray({200001: S.One / 3},
(100000, 200000))
# __neg__
assert -a == MutableSparseNDimArray({200001: -1}, (100000, 200000))
def test_slices():
md = MutableDenseNDimArray(range(10, 34), (2, 3, 4))
assert md[:] == MutableDenseNDimArray(range(10, 34), (2, 3, 4))
assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]])
assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]])
assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]])
assert md[:, :, :] == md
sd = MutableSparseNDimArray(range(10, 34), (2, 3, 4))
assert sd == MutableSparseNDimArray(md)
assert sd[:] == MutableSparseNDimArray(range(10, 34), (2, 3, 4))
assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]])
assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]])
assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]])
assert sd[:, :, :] == sd
def test_calculation():
a = MutableDenseNDimArray([1]*9, (3, 3))
b = MutableDenseNDimArray([9]*9, (3, 3))
c = a + b
for i in c:
assert i == 10
assert c == MutableDenseNDimArray([10]*9, (3, 3))
assert c == MutableSparseNDimArray([10]*9, (3, 3))
c = b - a
for i in c:
assert i == 8
assert c == MutableDenseNDimArray([8]*9, (3, 3))
assert c == MutableSparseNDimArray([8]*9, (3, 3))
def test_slices_assign():
a = MutableDenseNDimArray(range(12), shape=(4, 3))
b = MutableSparseNDimArray(range(12), shape=(4, 3))
for i in [a, b]:
assert i.tolist() == [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
i[0, :] = [2, 2, 2]
assert i.tolist() == [[2, 2, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
i[0, 1:] = [8, 8]
assert i.tolist() == [[2, 8, 8], [3, 4, 5], [6, 7, 8], [9, 10, 11]]
i[1:3, 1] = [20, 44]
assert i.tolist() == [[2, 8, 8], [3, 20, 5], [6, 44, 8], [9, 10, 11]]
def test_ndim_array_converting():
dense_array = MutableDenseNDimArray([1, 2, 3, 4], (2, 2))
alist = dense_array.tolist()
alist == [[1, 2], [3, 4]]
matrix = dense_array.tomatrix()
assert (isinstance(matrix, Matrix))
for i in range(len(dense_array)):
assert dense_array[i] == matrix[i]
assert matrix.shape == dense_array.shape
sparse_array = MutableSparseNDimArray([1, 2, 3, 4], (2, 2))
alist = sparse_array.tolist()
assert alist == [[1, 2], [3, 4]]
matrix = sparse_array.tomatrix()
assert(isinstance(matrix, SparseMatrix))
for i in range(len(sparse_array)):
assert sparse_array[i] == matrix[i]
assert matrix.shape == sparse_array.shape
def get_costs(self):
costs = []
for n in range(self.time_points):
# minimize error at each time step
costs.append((self.state_sym[0, n] - self.set_point[0])**2)
costs.append((self.state_sym[1, n] - self.set_point[1])**2)
costs.append((self.state_sym[2, n] - self.set_point[2])**2)
costs.append((self.state_sym[3, n] - self.set_point[3])**2)
#costs.append((self.state_sym[4,n]-self.set_point[4])**2)
#costs.append((self.state_sym[5,n]-self.set_point[5])**2)
# minimize the control signal at each time set
if n != self.time_points:
costs.append(self.state_sym[4, n]**2)
costs = MutableSparseNDimArray(costs, (len(costs), 1))
self.costs = costs
def test_ndim_array_initiation():
arr_with_one_element = MutableDenseNDimArray([23])
assert len(arr_with_one_element) == 1
assert arr_with_one_element[0] == 23
assert arr_with_one_element.rank() == 1
raises(ValueError, lambda: arr_with_one_element[1])
arr_with_symbol_element = MutableDenseNDimArray([Symbol('x')])
assert len(arr_with_symbol_element) == 1
assert arr_with_symbol_element[0] == Symbol('x')
assert arr_with_symbol_element.rank() == 1
number5 = 5
vector = MutableDenseNDimArray.zeros(number5)
assert len(vector) == number5
assert vector.shape == (number5, )
assert vector.rank() == 1
raises(ValueError, lambda: arr_with_one_element[5])
vector = MutableSparseNDimArray.zeros(number5)
assert len(vector) == number5
assert vector.shape == (number5, )
assert vector._sparse_array == {}
assert vector.rank() == 1
n_dim_array = MutableDenseNDimArray(range(3**4), (
3,
3,
3,
3,
))
assert len(n_dim_array) == 3 * 3 * 3 * 3
assert n_dim_array.shape == (3, 3, 3, 3)
assert n_dim_array.rank() == 4
raises(ValueError, lambda: n_dim_array[0, 0, 0, 3])
raises(ValueError, lambda: n_dim_array[3, 0, 0, 0])
raises(ValueError, lambda: n_dim_array[3**4])
array_shape = (3, 3, 3, 3)
sparse_array = MutableSparseNDimArray.zeros(*array_shape)
assert len(sparse_array._sparse_array) == 0
assert len(sparse_array) == 3 * 3 * 3 * 3
assert n_dim_array.shape == array_shape
assert n_dim_array.rank() == 4
one_dim_array = MutableDenseNDimArray([2, 3, 1])
assert len(one_dim_array) == 3
assert one_dim_array.shape == (3, )
assert one_dim_array.rank() == 1
assert one_dim_array.tolist() == [2, 3, 1]
shape = (3, 3)
array_with_many_args = MutableSparseNDimArray.zeros(*shape)
assert len(array_with_many_args) == 3 * 3
assert array_with_many_args.shape == shape
assert array_with_many_args[0, 0] == 0
assert array_with_many_args.rank() == 2
shape = (long(3), long(3))
array_with_long_shape = MutableSparseNDimArray.zeros(*shape)
assert len(array_with_long_shape) == 3 * 3
assert array_with_long_shape.shape == shape
assert array_with_long_shape[long(0), long(0)] == 0
assert array_with_long_shape.rank() == 2
vector_with_long_shape = MutableDenseNDimArray(range(5), long(5))
assert len(vector_with_long_shape) == 5
assert vector_with_long_shape.shape == (long(5), )
assert vector_with_long_shape.rank() == 1
raises(ValueError, lambda: vector_with_long_shape[long(5)])
from sympy.abc import x
for ArrayType in [MutableDenseNDimArray, MutableSparseNDimArray]:
rank_zero_array = ArrayType(x)
assert len(rank_zero_array) == 1
assert rank_zero_array.shape == ()
assert rank_zero_array.rank() == 0
assert rank_zero_array[()] == x
raises(ValueError, lambda: rank_zero_array[0])
def get_constraints(self):
(m1, m2, l1, l2, g) = self.plant_parameters
constraints = []
# Dynamics based constraints
for n in range(1, self.time_points):
# Each of these get a lambda in front of them.
# x0n
constraints.append(
self.lambdas[0, 4 * (n - 1) + 0] *
(self.state_sym[0, n] - self.state_sym[0, n - 1] -
self.state_sym[2, n - 1] * self.controller_resolution))
# x1n
constraints.append(
self.lambdas[0, 4 * (n - 1) + 1] *
(self.state_sym[1, n] - self.state_sym[1, n - 1] -
self.state_sym[3, n - 1] * self.controller_resolution))
# x2n
#constraints.append(self.lambdas[0,6*(n-1)+2] * (self.state_sym[2,n]-self.state_sym[2,n-1]- self.state_sym[4,n-1]*self.controller_resolution))
n_a = -1 * m2 * l1 * self.state_sym[2, n - 1] * sympy.sin(
self.state_sym[0, n - 1] - self.state_sym[1, n - 1])
n_b = m2 * g * sympy.sin(self.state_sym[1, n - 1])
n_1 = (n_a + n_b) * sympy.cos(self.state_sym[0, n - 1] -
self.state_sym[1, n - 1])
n_2 = -1 * m2 * l2 * self.state_sym[3, n - 1]**2 * sympy.sin(
self.state_sym[0, n - 1] - self.state_sym[1, n - 1])
n_3 = -1 * (m1 + m2) * g * sympy.sin(self.state_sym[0, n - 1])
d_1 = (m1 + m2) * l1
d_2 = -m2 * l1 * sympy.cos(self.state_sym[0, n - 1] -
self.state_sym[1, n - 1])**2
alpha_1 = (n_1 + n_2 + n_3) / (d_1 + d_2) + self.state_sym[4,
n - 1]
constraints.append(
self.lambdas[0, 4 * (n - 1) + 2] *
(self.state_sym[2, n] - self.state_sym[2, n - 1] -
(alpha_1) * self.controller_resolution))
# x3n
#constraints.append(self.lambdas[0,4*(n-1)+3] * (self.state_sym[3,n]-self.state_sym[3,n-1]- self.state_sym[5,n-1]*self.controller_resolution))
n_a = m2 * l2 * self.state_sym[3, n - 1]**2 * sympy.sin(
self.state_sym[0, n - 1] - self.state_sym[1, n - 1])
n_b = -(m1 + m2) * g * sympy.sin(self.state_sym[0, n - 1])
n_c = (m1 + m2) * l1
n_1 = -m2 * l1 * l2 * (n_a + n_b) / n_c * sympy.cos(
self.state_sym[0, n - 1] - self.state_sym[1, n - 1])
n_2 = m2 * l1 * l2 * self.state_sym[2, n - 1] * sympy.sin(
self.state_sym[0, n - 1] - self.state_sym[1, n - 1])
n_3 = -1 * m2 * g * l2 * sympy.sin(self.state_sym[1, n - 1])
d_1 = m2 * l2**2
d_2 = m2**2 * l1 * l2**2 * sympy.cos(
self.state_sym[0, n - 1] - self.state_sym[1, n - 1])**2 / n_c
alpha_2 = (n_1 + n_2 + n_3) / (d_1 + d_2)
constraints.append(
self.lambdas[0, 4 * (n - 1) + 3] *
(self.state_sym[3, n] - self.state_sym[3, n - 1] -
(alpha_2) * self.controller_resolution))
# x4n
#constraints.append(self.lambdas[0,6*(n-1)+4] * (self.state_sym[4,n] + m2*l2/((m1+m2)*l1)*self.state_sym[5,n-1] * sympy.cos(self.state_sym[0,n-1]-self.state_sym[1,n-1]) + m2*l2/((m1+m2)*l1)*self.state_sym[3,n-1]**2 *sympy.sin(self.state_sym[0,n-1]-self.state_sym[1,n-1]) +g/l1*sympy.sin(self.state_sym[0,n-1]) -self.state_sym[6,n-1] ) )
# x5n
#constraints.append(self.lambdas[0,6*(n-1)+5] * (self.state_sym[5,n] -l1/l2*self.state_sym[2,n-1]**2 * sympy.sin(self.state_sym[0,n-1]-self.state_sym[1,n-1]) +g/l2*sympy.sin(self.state_sym[1,n-1]) +l1/l2*self.state_sym[4,n-1]*sympy.cos(self.state_sym[0,n-1]-self.state_sym[1,n-1]) ) )
# Initial conditions boundary
constraints.append(
self.lambdas[0, 4 * (n) + 0] *
(self.state_sym[0, 0] - self.initial_conditions[0])**2)
constraints.append(
self.lambdas[0, 4 * (n) + 1] *
(self.state_sym[1, 0] - self.initial_conditions[1])**2)
constraints.append(
self.lambdas[0, 4 * (n) + 2] *
(self.state_sym[2, 0] - self.initial_conditions[2])**2)
constraints.append(
self.lambdas[0, 4 * (n) + 3] *
(self.state_sym[3, 0] - self.initial_conditions[3])**2)
#constraints.append(self.lambdas[0,6*(n)+4] * (self.state_sym[4,0] - self.initial_conditions[4])**2 )
#constraints.append(self.lambdas[0,6*(n)+5] * (self.state_sym[5,0] - self.initial_conditions[5])**2 )
# End condition boundary
constraints.append(
self.lambdas[0, 4 * (n) + 4] *
(self.state_sym[0, self.time_points - 1] - self.set_point[0])**2)
constraints.append(
self.lambdas[0, 4 * (n) + 5] *
(self.state_sym[1, self.time_points - 1] - self.set_point[1])**2)
constraints.append(
self.lambdas[0, 4 * (n) + 6] *
(self.state_sym[2, self.time_points - 1] - self.set_point[2])**2)
constraints.append(
self.lambdas[0, 4 * (n) + 7] *
(self.state_sym[3, self.time_points - 1] - self.set_point[3])**2)
#constraints.append(self.lambdas[0,6*(n)+10] * (self.state_sym[4,self.time_points-1] - self.set_point[4])**2 )
#constraints.append(self.lambdas[0,6*(n)+11] * (self.state_sym[5,self.time_points-1] - self.set_point[5])**2 )
constraints = MutableSparseNDimArray(constraints,
(len(constraints), 1))
self.constraints = constraints