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