def test_fcode_results_named_ordered():
x, y, z = symbols('x,y,z')
B, C = symbols('B,C')
A = MatrixSymbol('A', 1, 3)
expr1 = Equality(A, Matrix([[1, 2, x]]))
expr2 = Equality(C, (x + y)*z)
expr3 = Equality(B, 2*x)
name_expr = ("test", [expr1, expr2, expr3])
result = codegen(name_expr, "f95", "test", header=False, empty=False,
argument_sequence=(x, z, y, C, A, B))
source = result[0][1]
expected = (
"subroutine test(x, z, y, C, A, B)\n"
"implicit none\n"
"REAL*8, intent(in) :: x\n"
"REAL*8, intent(in) :: z\n"
"REAL*8, intent(in) :: y\n"
"REAL*8, intent(out) :: C\n"
"REAL*8, intent(out) :: B\n"
"REAL*8, intent(out), dimension(1:1, 1:3) :: A\n"
"C = z*(x + y)\n"
"A(1, 1) = 1\n"
"A(1, 2) = 2\n"
"A(1, 3) = x\n"
"B = 2*x\n"
"end subroutine\n"
)
assert source == expected
def test_InOutArgument_order():
# can specify the order as (x, y)
expr = Equality(x, x**2 + y)
name_expr = ("test", expr)
result, = codegen(name_expr,
"Rust",
header=False,
empty=False,
argument_sequence=(x, y))
source = result[1]
expected = ("fn test(x: f64, y: f64) -> f64 {\n"
" let x = x.powi(2) + y;\n"
" x\n"
"}\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, "Rust", header=False, empty=False)
source = result[1]
expected = ("fn test(x: f64, y: f64) -> f64 {\n"
" let x = x.powi(2) + y;\n"
" x\n"
"}\n")
assert source == expected
def test_fcode_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, "f95", "test", header=False, empty=False)
source = result[0][1]
expected = (
"subroutine test(A, B, C, D)\n"
"implicit none\n"
"REAL*8, intent(in), dimension(1:2, 1:3) :: A\n"
"REAL*8, intent(out), dimension(1:1, 1:3) :: B\n"
"REAL*8, intent(out), dimension(1:1, 1:3) :: C\n"
"REAL*8, intent(out), dimension(1:2, 1:1) :: D\n"
"B(1, 1) = A(1, 1)\n"
"B(1, 2) = A(1, 2)\n"
"B(1, 3) = A(1, 3)\n"
"C(1, 1) = A(2, 1)\n"
"C(1, 2) = A(2, 2)\n"
"C(1, 3) = A(2, 3)\n"
"D(1, 1) = A(1, 3)\n"
"D(2, 1) = A(2, 3)\n"
"end subroutine\n"
)
assert source == expected
def test_ccode_results_named_ordered():
x, y, z = symbols('x,y,z')
B, C = symbols('B,C')
A = MatrixSymbol('A', 1, 3)
expr1 = Equality(A, Matrix([[1, 2, x]]))
expr2 = Equality(C, (x + y)*z)
expr3 = Equality(B, 2*x)
name_expr = ("test", [expr1, expr2, expr3])
expected = (
'#include "test.h"\n'
'#include <math.h>\n'
'void test(double x, double *C, double z, double y, double *A, double *B) {\n'
' (*C) = z*(x + y);\n'
' A[0] = 1;\n'
' A[1] = 2;\n'
' A[2] = x;\n'
' (*B) = 2*x;\n'
'}\n'
)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=SymPyDeprecationWarning)
result = codegen(name_expr, "c", "test", header=False, empty=False,
argument_sequence=(x, C, z, y, A, B))
source = result[0][1]
assert source == expected
def print_equation(before_equal, after_equal, no_simplify=False):
if not no_simplify:
after_equal = simplify(after_equal)
before_equal = simplify(before_equal)
pprint(Equality(before_equal, after_equal))
print(latex(Equality(before_equal, after_equal)))
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_ccode_matrixsymbol_slice():
A = MatrixSymbol('A', 5, 3)
B = MatrixSymbol('B', 1, 3)
C = MatrixSymbol('C', 1, 3)
D = MatrixSymbol('D', 5, 1)
name_expr = ("test", [Equality(B, A[0, :]),
Equality(C, A[1, :]),
Equality(D, A[:, 2])])
result = codegen(name_expr, "c99", "test", header=False, empty=False)
source = result[0][1]
expected = (
'#include "test.h"\n'
'#include <math.h>\n'
'void test(double *A, double *B, double *C, double *D) {\n'
' B[0] = A[0];\n'
' B[1] = A[1];\n'
' B[2] = A[2];\n'
' C[0] = A[3];\n'
' C[1] = A[4];\n'
' C[2] = A[5];\n'
' D[0] = A[2];\n'
' D[1] = A[5];\n'
' D[2] = A[8];\n'
' D[3] = A[11];\n'
' D[4] = A[14];\n'
'}\n'
)
assert source == expected
def test_m_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, "Octave", header=False, empty=False)
source = result[1]
expected = ("function [B, C] = test(A)\n"
" B = A(1:2, 1:2);\n"
" C = A(1:2, 2:3);\n"
"end\n")
assert source == expected
def test_m_matrixsymbol_slice3():
A = MatrixSymbol('A', 8, 7)
B = MatrixSymbol('B', 2, 2)
C = MatrixSymbol('C', 4, 2)
name_expr = ("test", [Equality(B, A[6:, 1::3]), Equality(C, A[::2, ::3])])
result, = codegen(name_expr, "Octave", header=False, empty=False)
source = result[1]
expected = ("function [B, C] = test(A)\n"
" B = A(7:end, 2:3:end);\n"
" C = A(1:2:end, 1:3:end);\n"
"end\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_jl_matrixsymbol_slice3():
A = MatrixSymbol('A', 8, 7)
B = MatrixSymbol('B', 2, 2)
C = MatrixSymbol('C', 4, 2)
name_expr = ("test", [Equality(B, A[6:, 1::3]), Equality(C, A[::2, ::3])])
result, = codegen(name_expr, "Julia", header=False, empty=False)
source = result[1]
expected = ("function test(A)\n"
" B = A[7:end,2:3:end]\n"
" C = A[1:2:end,1:3:end]\n"
" return B, C\n"
"end\n")
assert source == expected
def test_simplification():
"""
Test working of simplification methods.
"""
set1 = [[0, 0, 1], [0, 1, 1], [1, 0, 0], [1, 1, 0]]
set2 = [[0, 0, 0], [0, 1, 0], [1, 0, 1], [1, 1, 1]]
from sympy.abc import w, x, y, z
assert SOPform([x, y, z], set1) == Or(And(Not(x), z), And(Not(z), x))
assert Not(SOPform([x, y, z], set2)) == Not(Or(And(Not(x), Not(z)), And(x, z)))
assert POSform([x, y, z], set1 + set2) is true
assert SOPform([x, y, z], set1 + set2) is true
assert SOPform([Dummy(), Dummy(), Dummy()], set1 + set2) is true
minterms = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1], [1, 0, 1, 1],
[1, 1, 1, 1]]
dontcares = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 1]]
assert (
SOPform([w, x, y, z], minterms, dontcares) ==
Or(And(Not(w), z), And(y, z)))
assert POSform([w, x, y, z], minterms, dontcares) == And(Or(Not(w), y), z)
# test simplification
ans = And(A, Or(B, C))
assert simplify_logic(A & (B | C)) == ans
assert simplify_logic((A & B) | (A & C)) == ans
assert simplify_logic(Implies(A, B)) == Or(Not(A), B)
assert simplify_logic(Equivalent(A, B)) == \
Or(And(A, B), And(Not(A), Not(B)))
assert simplify_logic(And(Equality(A, 2), C)) == And(Equality(A, 2), C)
assert simplify_logic(And(Equality(A, 2), A)) == And(Equality(A, 2), A)
assert simplify_logic(And(Equality(A, B), C)) == And(Equality(A, B), C)
assert simplify_logic(Or(And(Equality(A, 3), B), And(Equality(A, 3), C))) \
== And(Equality(A, 3), Or(B, C))
e = And(A, x**2 - x)
assert simplify_logic(e) == And(A, x*(x - 1))
assert simplify_logic(e, deep=False) == e
# check input
ans = SOPform([x, y], [[1, 0]])
assert SOPform([x, y], [[1, 0]]) == ans
assert POSform([x, y], [[1, 0]]) == ans
raises(ValueError, lambda: SOPform([x], [[1]], [[1]]))
assert SOPform([x], [[1]], [[0]]) is true
assert SOPform([x], [[0]], [[1]]) is true
assert SOPform([x], [], []) is false
raises(ValueError, lambda: POSform([x], [[1]], [[1]]))
assert POSform([x], [[1]], [[0]]) is true
assert POSform([x], [[0]], [[1]]) is true
assert POSform([x], [], []) is false
# check working of simplify
assert simplify((A & B) | (A & C)) == And(A, Or(B, C))
assert simplify(And(x, Not(x))) == False
assert simplify(Or(x, Not(x))) == True
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, "Octave", header=False, empty=False)
source = result[1]
expected = ("function [C, A, B] = test(x, y, z)\n"
" C = z.*(x + y);\n"
" A = z.*(x - y);\n"
" B = 2*x;\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_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_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_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_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_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_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_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_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 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_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
