def test_results_named_unordered():
# Here output order is based on name_expr
A, B, C = symbols('A,B,C')
expr1 = Equality(C, (x + y) * z)
expr2 = Equality(A, (x - y) * z)
expr3 = Equality(B, 2 * x)
name_expr = ("test", [expr1, expr2, expr3])
result, = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = ("function test(x, y, z)\n"
" C = z.*(x + y)\n"
" A = z.*(x - y)\n"
" B = 2*x\n"
" return C, A, B\n"
"end\n")
assert source == expected
def test_m_simple_code_nameout():
expr = Equality(z, (x + y))
name_expr = ("test", expr)
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function z = test(x, y)\n" " z = x + y;\n" "end\n")
assert source == expected
def test_jl_simple_code_nameout():
expr = Equality(z, (x + y))
name_expr = ("test", expr)
(result, ) = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = "function test(x, y)\n" " z = x + y\n" " return z\n" "end\n"
assert source == expected
def test_jl_InOutArgument():
expr = Equality(x, x**2)
name_expr = ("mysqr", expr)
(result, ) = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = "function mysqr(x)\n" " x = x.^2\n" " return x\n" "end\n"
assert source == expected
def test_results_named_unordered():
# Here output order is based on name_expr
A, B, C = symbols('A,B,C')
expr1 = Equality(C, (x + y) * z)
expr2 = Equality(A, (x - y) * z)
expr3 = Equality(B, 2 * x)
name_expr = ("test", [expr1, expr2, expr3])
result, = codegen(name_expr, "Rust", header=False, empty=False)
source = result[1]
expected = ("fn test(x: f64, y: f64, z: f64) -> (f64, f64, f64) {\n"
" let C = z*(x + y);\n"
" let A = z*(x - y);\n"
" let B = 2*x;\n"
" (C, A, B)\n"
"}\n")
assert source == expected
def test_InOutArgument():
expr = Equality(x, x**2)
name_expr = ("mysqr", expr)
(result, ) = codegen(name_expr, "Rust", header=False, empty=False)
source = result[1]
expected = "fn mysqr(x: f64) -> f64 {\n" " let x = x.powi(2);\n" " x\n" "}\n"
assert source == expected
def test_jl_matrixsymbol_slice2():
A = MatrixSymbol('A', 3, 4)
B = MatrixSymbol('B', 2, 2)
C = MatrixSymbol('C', 2, 2)
name_expr = ("test", [Equality(B, A[0:2, 0:2]),
Equality(C, A[0:2, 1:3])])
result, = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = (
"function test(A)\n"
" B = A[1:2,1:2]\n"
" C = A[1:2,2:3]\n"
" return B, C\n"
"end\n"
)
assert source == expected
def test_m_InOutArgument():
expr = Equality(x, x**2)
name_expr = ("mysqr", expr)
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function x = mysqr(x)\n" " x = x.^2;\n" "end\n")
assert source == expected
def test_as_relational(self):
left = x + x**2
right = cos(x)
eq = Equation(left, right)
self.assertEqual(eq.as_relational(), Equality(left, right))
self.assertEqual(eq.as_relational(GreaterThan),
GreaterThan(left, right))
def test_m_output_arg_mixed_unordered():
# named outputs are alphabetical, unnamed output appear in the given order
from sympy import sin, cos, tan
a = symbols("a")
name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
result, = codegen(name_expr, "Octave", header=False, empty=False)
assert result[0] == "foo.m"
source = result[1];
expected = (
'function [out1, y, out3, a] = foo(x)\n'
' out1 = cos(2*x);\n'
' y = sin(x);\n'
' out3 = cos(x);\n'
' a = sin(2*x);\n'
'end\n'
)
assert source == expected
def test_m_matrix_named_matsym():
myout1 = MatrixSymbol("myout1", 1, 3)
e2 = Matrix([[x, 2 * y, pi * z]])
name_expr = ("test", Equality(myout1, e2, evaluate=False))
(result, ) = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = "function myout1 = test(x, y, z)\n" " myout1 = [x 2*y pi*z];\n" "end\n"
assert source == expected
def test_m_matrix_named():
e2 = Matrix([[x, 2 * y, pi * z]])
name_expr = ("test", Equality(MatrixSymbol("myout1", 1, 3), e2))
result = codegen(name_expr, "Octave", header=False, empty=False)
assert result[0][0] == "test.m"
source = result[0][1]
expected = "function myout1 = test(x, y, z)\n" " myout1 = [x 2*y pi*z];\n" "end\n"
assert source == expected
def test_m_matrixsymbol_slice():
A = MatrixSymbol('A', 2, 3)
B = MatrixSymbol('B', 1, 3)
C = MatrixSymbol('C', 1, 3)
D = MatrixSymbol('D', 2, 1)
name_expr = ("test", [
Equality(B, A[0, :]),
Equality(C, A[1, :]),
Equality(D, A[:, 2])
])
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function [B, C, D] = test(A)\n"
" B = A(1, :);\n"
" C = A(2, :);\n"
" D = A(:, 3);\n"
"end\n")
assert source == expected
def test_results_named_ordered():
A, B, C = symbols('A,B,C')
expr1 = Equality(C, (x + y)*z)
expr2 = Equality(A, (x - y)*z)
expr3 = Equality(B, 2*x)
name_expr = ("test", [expr1, expr2, expr3])
result = codegen(name_expr, "Octave", header=False, empty=False,
argument_sequence=(x, z, y))
assert result[0][0] == "test.m"
source = result[0][1]
expected = (
"function [C, A, B] = test(x, z, y)\n"
" C = z.*(x + y);\n"
" A = z.*(x - y);\n"
" B = 2*x;\n"
"end\n"
)
assert source == expected
def test_m_results_matrix_named_ordered():
B, C = symbols('B,C')
A = MatrixSymbol('A', 1, 3)
expr1 = Equality(C, (x + y)*z)
expr2 = Equality(A, Matrix([[1, 2, x]]))
expr3 = Equality(B, 2*x)
name_expr = ("test", [expr1, expr2, expr3])
result, = codegen(name_expr, "Octave", header=False, empty=False,
argument_sequence=(x, z, y))
source = result[1]
expected = (
"function [C, A, B] = test(x, z, y)\n"
" C = z.*(x + y);\n"
" A = [1 2 x];\n"
" B = 2*x;\n"
"end\n"
)
assert source == expected
def test_convert(self):
eq = Equation(x * y, y + z)
self.assertEqual(eq.as_expr(), x * y - (y + z))
r1 = eq.as_relational()
self.assertTrue(
isinstance(r1, Equality) and (r1 == Equality(x * y, y + z)))
r2 = eq.as_relational(GreaterThan)
self.assertTrue(
isinstance(r2, GreaterThan) and (r2 == GreaterThan(x * y, y + z)))
def test_output_arg_mixed_unordered():
# named outputs are alphabetical, unnamed output appear in the given order
from sympy import sin, cos
a = symbols("a")
name_expr = ("foo", [cos(2*x), Equality(y, sin(x)), cos(x), Equality(a, sin(2*x))])
result, = codegen(name_expr, "Rust", header=False, empty=False)
assert result[0] == "foo.rs"
source = result[1];
expected = (
"fn foo(x: f64) -> (f64, f64, f64, f64) {\n"
" let out1 = (2*x).cos();\n"
" let y = x.sin();\n"
" let out3 = x.cos();\n"
" let a = (2*x).sin();\n"
" (out1, y, out3, a)\n"
"}\n"
)
assert source == expected
def sympy_eqn(c, interactions=None, include_bias=True):
"""
Return a symbolic expression for a polynomial produced by brutefit.
Parameter numbers correspond to column indices in the design matrix.
Parameters
----------
c : array-like
A sequence of N integers specifying the polynomial order
of each covariate, OR a row of a dataframe produced by
evaluate_polynomials.
interactions : None or array-like
If None, no parameter interactions are included.
If not None, it should be an array of integers the same length as the number
of combinations of parameters in c, i.e. if c=[1,1,1]: interactions=[1, 1, 1, 1, 1, 1],
where each integer correspons to the order of the interaction between covariates
[01, 02, 03, 12, 13, 23].
include_bias : bool
Whether or not to include a bias term (intercept) in the fit.
"""
if isinstance(c, pd.core.series.Series):
interactions = c.loc['interactions'].values
include_bias = c.loc[('model', 'include_bias')]
c = c.loc['orders'].values
c = np.asanyarray(c)
interaction_pairs = np.vstack(np.triu_indices(len(c), 1)).T
if interactions is not None:
interactions = np.asanyarray(interactions)
if interaction_pairs.shape[0] != interactions.size:
msg = '\nNot enough interactions specified. Should be {} for {} covariates.'.format(interaction_pairs.shape[0], c.size)
msg += '\nSpecifying the orders of interactions between: [' + ', '.join(['{}{}'.format(*i) for i in interaction_pairs]) + ']'
raise ValueError(msg)
if interactions.max() > c.max():
print('WARNING: interactions powers are higher than non-interaction powers.')
xs = symbols(['x_{}'.format(i) for i in range(len(c))])
if include_bias:
eqn = [symbols('p_0')]
else:
eqn = []
p = 1
for o in range(1, c.max() + 1):
for x in sel_xs(xs, c>=o):
eqn.append(symbols('p_{}'.format(p)) * x**o)
p += 1
if interactions is not None:
for o in range(1, interactions.max() + 1):
for ip in interaction_pairs[interactions >= o, :]:
eqn.append(symbols('p_{}'.format(p)) * xs[ip[0]]**o * xs[ip[1]]**o)
p += 1
return Equality(symbols('y'), Add(*eqn))
def test_results_named_ordered():
A, B, C = symbols('A,B,C')
expr1 = Equality(C, (x + y)*z)
expr2 = Equality(A, (x - y)*z)
expr3 = Equality(B, 2*x)
name_expr = ("test", [expr1, expr2, expr3])
result = codegen(name_expr, "Rust", header=False, empty=False,
argument_sequence=(x, z, y))
assert result[0][0] == "test.rs"
source = result[0][1]
expected = (
"fn test(x: f64, z: f64, y: f64) -> (f64, f64, f64) {\n"
" let C = z*(x + y);\n"
" let A = z*(x - y);\n"
" let B = 2*x;\n"
" (C, A, B)\n"
"}\n"
)
assert source == expected
def test_jl_InOutArgument_order():
# can specify the order as (x, y)
expr = Equality(x, x**2 + y)
name_expr = ("test", expr)
(result, ) = codegen(name_expr,
"Julia",
header=False,
empty=False,
argument_sequence=(x, y))
source = result[1]
expected = "function test(x, y)\n" " x = x.^2 + y\n" " return x\n" "end\n"
assert source == expected
# make sure it gives (x, y) not (y, x)
expr = Equality(x, x**2 + y)
name_expr = ("test", expr)
(result, ) = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = "function test(x, y)\n" " x = x.^2 + y\n" " return x\n" "end\n"
assert source == expected
def test_m_InOutArgument_order():
# can specify the order as (x, y)
expr = Equality(x, x**2 + y)
name_expr = ("test", expr)
result, = codegen(name_expr,
"Octave",
header=False,
empty=False,
argument_sequence=(x, y))
source = result[1]
expected = ("function x = test(x, y)\n" " x = x.^2 + y;\n" "end\n")
assert source == expected
# make sure it gives (x, y) not (y, x)
expr = Equality(x, x**2 + y)
name_expr = ("test", expr)
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function x = test(x, y)\n" " x = x.^2 + y;\n" "end\n")
assert source == expected
def test_Equivalent():
assert Equivalent(A, B) == Equivalent(B, A) == Equivalent(A, B, A)
assert Equivalent() is true
assert Equivalent(A, A) == Equivalent(A) is true
assert Equivalent(True, True) == Equivalent(False, False) is true
assert Equivalent(True, False) == Equivalent(False, True) is false
assert Equivalent(A, True) == A
assert Equivalent(A, False) == Not(A)
assert Equivalent(A, B, True) == A & B
assert Equivalent(A, B, False) == ~A & ~B
assert Equivalent(1, A) == A
assert Equivalent(0, A) == Not(A)
assert Equivalent(A, Equivalent(B, C)) != Equivalent(Equivalent(A, B), C)
assert Equivalent(A < 1, A >= 1) is false
assert Equivalent(A < 1, A >= 1, 0) is false
assert Equivalent(A < 1, A >= 1, 1) is false
assert Equivalent(A < 1, S(1) > A) == Equivalent(1, 1) == Equivalent(0, 0)
assert Equivalent(Equality(A, B), Equality(B, A)) is true
def test_simple_code_nameout():
expr = Equality(z, (x + y))
name_expr = ("test", expr)
result, = codegen(name_expr, "Rust", header=False, empty=False)
source = result[1]
expected = ("fn test(x: f64, y: f64) -> f64 {\n"
" let z = x + y;\n"
" z\n"
"}\n")
assert source == expected
def test_jl_matrixsymbol_slice():
A = MatrixSymbol('A', 2, 3)
B = MatrixSymbol('B', 1, 3)
C = MatrixSymbol('C', 1, 3)
D = MatrixSymbol('D', 2, 1)
name_expr = ("test", [Equality(B, A[0, :]),
Equality(C, A[1, :]),
Equality(D, A[:, 2])])
result, = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = (
"function test(A)\n"
" B = A[1,:]\n"
" C = A[2,:]\n"
" D = A[:,3]\n"
" return B, C, D\n"
"end\n"
)
assert source == expected
def test_jl_matrix_named_matsym():
myout1 = MatrixSymbol('myout1', 1, 3)
e2 = Matrix([[x, 2 * y, pi * z]])
name_expr = ("test", Equality(myout1, e2, evaluate=False))
result, = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = ("function test(x, y, z)\n"
" myout1 = [x 2*y pi*z]\n"
" return myout1\n"
"end\n")
assert source == expected
def test_jl_matrix_named():
e2 = Matrix([[x, 2 * y, pi * z]])
name_expr = ("test", Equality(MatrixSymbol('myout1', 1, 3), e2))
result = codegen(name_expr, "Julia", header=False, empty=False)
assert result[0][0] == "test.jl"
source = result[0][1]
expected = ("function test(x, y, z)\n"
" myout1 = [x 2*y pi*z]\n"
" return myout1\n"
"end\n")
assert source == expected
def test_jl_results_matrix_named_ordered():
B, C = symbols("B,C")
A = MatrixSymbol("A", 1, 3)
expr1 = Equality(C, (x + y) * z)
expr2 = Equality(A, Matrix([[1, 2, x]]))
expr3 = Equality(B, 2 * x)
name_expr = ("test", [expr1, expr2, expr3])
(result, ) = codegen(name_expr,
"Julia",
header=False,
empty=False,
argument_sequence=(x, z, y))
source = result[1]
expected = ("function test(x, z, y)\n"
" C = z.*(x + y)\n"
" A = [1 2 x]\n"
" B = 2*x\n"
" return C, A, B\n"
"end\n")
assert source == expected
def test_cython_wrapper_inoutarg():
from sympy import Equality
x, y, z = symbols('xyz')
code_gen = CythonCodeWrapper(CCodeGen())
routine = Routine("test", Equality(z, x + y + z))
source = get_string(code_gen.dump_pyx, [routine])
expected = ('cdef extern from "file.h":\n'
' void test(double x, double y, double &z)\n'
'def test_c(double x, double y, double z):\n'
' test(x, y, z)\n'
' return z\n')
assert source == expected
def test_m_matrixsymbol_slice_autoname():
A = MatrixSymbol('A', 2, 3)
B = MatrixSymbol('B', 1, 3)
name_expr = ("test", [Equality(B, A[0, :]), A[1, :], A[:, 0], A[:, 1]])
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function [B, out2, out3, out4] = test(A)\n"
" B = A(1, :);\n"
" out2 = A(2, :);\n"
" out3 = A(:, 1);\n"
" out4 = A(:, 2);\n"
"end\n")
assert source == expected
def _set_axis_and_point(self, cond_eq: sympy.Equality, coords: cs.CoordinateSystem):
coord_vars = coords.axises()
self.axis, self.axis_point = None, None
U = sympy.Function("u")
u_entrances = list(cond_eq.find(U))
if len(u_entrances) != 1:
raise ValueError(
"Cannot contain different args in U for derivative and u function"
)
a1 = sympy.Wild("a1", properties=[lambda x: x.is_constant])
a2 = sympy.Wild("a2", properties=[lambda x: x.is_constant])
u_pow = sympy.Wild("u_pow", properties=[lambda x: x.is_constant])
axis = sympy.Wild("axis", properties=[lambda x: x.is_symbol])
U_pattern = sympy.WildFunction("U_pattern", nargs=len(coords.axises()))
res = cond_eq.lhs.match(
a1 * U_pattern ** u_pow + a2 * sympy.Derivative(U_pattern, axis)
)
if res is None:
raise ValueError(f"Cannot parse {cond_eq}")
self.a1 = res[a1]
self.a2 = res[a2]
u_with_args = res[U_pattern]
if self.a1 != 0 and self.a2 == 0:
self.kind = ConditionKind.First.name
elif self.a1 == 0 and self.a2 != 0:
self.kind = ConditionKind.Second.name
elif self.a1 != 0 and self.a2 != 0:
self.kind = ConditionKind.Third.name
else:
raise ValueError(
f"Left side of boundary condition: {cond_eq} does"
"not contain u function"
)
for i, arg in enumerate(u_with_args.args):
if arg.is_constant():
self.axis = coord_vars[i]
self.axis_point = sympy.fcode(arg.evalf())
self._axis_point = arg
break
if self.axis is None:
raise ValueError(
"Bondary condition cannot be parsed"
"Probably you did not specified U arguments or"
"there is no constant in arguments"
)
