def test_plus(self):
expression_1 = self.x**2 + 3 * self.x - 4
expression_2 = self.x - 1
expression_3 = self.x**2 + 4 * self.x - 5
al_expression_1 = ALexpression(expression_1)
al_expression_2 = ALexpression(expression_2)
al_expression_3 = ALexpression(expression_3)
self.assertEqual(al_expression_1 + al_expression_2,
self.x**2 + 4 * self.x - 5)
self.assertEqual(al_expression_1 + al_expression_2, al_expression_3)
self.assertEqual((al_expression_1 + al_expression_2)(1), 0)
def test_plus():
x = sympy.var("x")
expression_1 = x**2 + 3 * x - 4
expression_2 = x - 1
expression_3 = x**2 + 4 * x - 5
al_expression_1 = ALexpression(expression_1)
al_expression_2 = ALexpression(expression_2)
al_expression_3 = ALexpression(expression_3)
assert al_expression_1 + al_expression_2 == x**2 + 4 * x - 5
assert al_expression_1 + al_expression_2 == al_expression_3
assert (al_expression_1 + al_expression_2)(1) == 0
def test_multiply_with_alexpression(self):
# Given
al_expression_1 = ALexpression(self.expression)
al_expression_2 = ALexpression(self.x)
# When
new_expression = al_expression_1 * al_expression_2
# Then
self.assertEqual(
sympy.simplify(new_expression.aform -
(self.x**3.0 + 3 * self.x**2 + 4.0 * self.x)),
0.0,
)
def test_negative():
x = sympy.var("x")
expression_1 = x**2 + 3 * x - 4
al_expression_1 = ALexpression(expression_1)
assert (-al_expression_1)(1) == 0
assert -al_expression_1 + (x**2 + 3 * x - 4) == 0
def test_init(self):
al_expression = ALexpression(self.expression)
self.assertIs(al_expression.aform, self.expression)
self.assertIs(al_expression._ALexpression__initial_aform,
self.expression)
self.assertEqual(al_expression.t, (self.x, ))
self.assertIsNone(al_expression.lform)
def test_div_mult(self):
expression_1 = self.x**2 + 3 * self.x - 4
expression_2 = self.x - 1
expression_3 = self.x + 4
al_expression_1 = ALexpression(expression_1)
al_expression_2 = ALexpression(expression_2)
al_expression_3 = ALexpression(expression_3)
trivial_expression_1 = al_expression_1 / al_expression_2 / al_expression_3
trivial_expression_2 = al_expression_3 * al_expression_2 / al_expression_1
self.assertEqual(trivial_expression_1.simplify(), 1)
self.assertEqual(trivial_expression_2.simplify(), 1)
self.assertEqual((al_expression_1 / al_expression_2)(1), 5)
self.assertEqual((al_expression_3 * al_expression_2)(2), 6)
def generate_curvature(self):
if self.space_dimension > 2:
warnings.warn(
"Only 2D version of {} is implemented. Current space dimension is {}"
.format("normal", self.space_dimension))
curvature = (
self.bspline_derivative[0].aform * self.bspline_hessian[1].aform -
self.bspline_derivative[1].aform *
self.bspline_hessian[0].aform) / self._arc_length.aform**3.0
return ALexpression(curvature)
def construct_derivative(self, expression, order):
if isinstance(expression, list):
derivative = [
self.construct_derivative(exp, order) for exp in expression
]
elif isinstance(expression, ALexpression):
derivative = ALexpression(
sympy.diff(expression.aform, self.x, order))
else:
raise NotImplementedError
return derivative
def test_divmult():
x = sympy.var("x")
expression_1 = x**2 + 3 * x - 4
expression_2 = x - 1
expression_3 = x + 4
al_expression_1 = ALexpression(expression_1)
al_expression_2 = ALexpression(expression_2)
al_expression_3 = ALexpression(expression_3)
trivial_expression_1 = al_expression_1 / al_expression_2 / al_expression_3
trivial_expression_2 = al_expression_3 * al_expression_2 / al_expression_1
trivial_expression_1.simplify()
trivial_expression_2.simplify()
assert trivial_expression_1 == 1
assert trivial_expression_2 == 1
assert (al_expression_1 / al_expression_2)(1) == 5
assert (al_expression_3 * al_expression_2)(2) == 6
def test_negative(self):
# Given
al_expression = ALexpression(self.expression)
# Then
self.assertEqual((-al_expression)(1), -8.0)
self.assertEqual(-al_expression + (self.x**2.0 + 3 * self.x + 4), 0)
# When
negative_expression = -al_expression
# Then
self.assertIsNot(negative_expression, -al_expression)
def construct_bspline_basis(self):
"""
Returns:
list of B-spline basis functions in ALexpression format
"""
bspline_basis = [
ALexpression(
sympy_bspline_basis(self.degree, tuple(self.kv), i,
self.x) # 1.0 *
) for i in range(len(self.cv))
]
return bspline_basis
def construct_bspline_expression(self):
"""
Returns:
N-dimensional list (N == self.space_dimension) of parametrized B-spline surface components
"""
bspline_expression = [0 for s in range(self.space_dimension)]
for i in range(len(self.cv)):
for j in range(self.space_dimension):
bspline_expression[
j] += self.cv[i][j] * self.bspline_basis[i].aform
return [
ALexpression(bspline_expression[i])
for i in range(self.space_dimension)
]
def test_multiply_number(self):
# Given
al_expression = ALexpression(self.expression)
# When
new_expression = al_expression * 42
# Then
self.assertIsInstance(new_expression, ALexpression)
self.assertEqual(
sympy.simplify(new_expression.aform -
(42.0 * self.x**2.0 + 42.0 * 3.0 * self.x +
42.0 * 4.0)),
0.0,
)
def test_lform():
x = sympy.var("x")
expression = x**2 + 3 * x + 4
al_expression = ALexpression(expression)
assert al_expression(2.0) == 14.0
def test_no_free_variables(self):
al_expression = ALexpression(sympy.pi)
self.assertAlmostEqual(al_expression(2), 3.1415926, places=6)
def test___call__raises(self):
al_expression = ALexpression(self.expression)
with self.assertRaises(TypeError):
al_expression("abc")
def test___call__(self):
al_expression = ALexpression(self.expression)
self.assertEqual(al_expression(2.0), 14.0)
self.assertEqual(al_expression(2), 14.0)
def generate_arc_length(self):
L = ALexpression(
sympy.sqrt(
np.inner(self.bspline_derivative,
self.bspline_derivative).aform))
return L
