SymEngine doesn't work after rscale changes

When I reviewed the rscale patch I guess I didn't actually test that the code worked with SymEngine (I thought I did but I guess the unit tests I ran did not exercise everything).

• matrix / scalar doesn't work. matrix * scalar**-1 works instead (This seems like it ought to be fixed in SymEngine).
• deep is not a kwarg to .expand() in SymEngine
• subs() takes a dict as argument, not a list

cc @isuruf

Sorry about that! Do we have tests for symengine? If so, did I manage to overlook them?

Fortunately those all look like manageable fixes.

We don't have dedicated SymEngine tests. It wouldn't be too hard to add them. We would have to make sure the results aren't cached.

Right now to exercise SymEngine you have to run from a cold cache for most things.

Workarounds @mattwala mentioned will have to be done until SymEngine is fixed and released.

1. https://github.com/symengine/symengine.py/pull/184
2. What does deep=False do?
3. https://github.com/symengine/symengine.py/pull/185

Awesome, thanks!

What does deep=False do?

My perception is that it would expand only the "outermost" product, rather than "every product in sight".

My perception is that it would expand only the "outermost" product, rather than "every product in sight".

That was what I thought too initially, but it doesn't do what I though it would.

In [110]: expand(2*(x+y+3*(x-y)), deep=False)
Out[110]: 8*x - 4*y

Huh, interesting. Only expanding one layer of products was the intention anyway--is there a function in sympy and/or symengine that accomplishes that?

-is there a function in sympy and/or symengine that accomplishes that?

Not that I know of, but it should be easy to write a custom function for it.

Btw, do you really need subs using a list? Is it supposed to be unordered? For example, what do you expect (x + 2*y).subs([(x, y), (y, x)]) to give you?

Btw, do you really need subs using a list?

No--it's not totally necessary (though I feel safer if it is). It was more an efficiency concern, where it was clear that if I were to call .subs() multiple times, I would have to pay for multiple traversals of the expression tree.

Is it supposed to be unordered?

Yeah.

For example, what do you expect (x + 2*y).subs([(x, y), (y, x)]) to give you?

It should swap the x's and the y's.

(x + 2*y).subs([(x, y), (y, x)]) currently gives you 3*x because there are multiple traversals. In SymPy, .subs(simultaneous=True) would save you multiple traversals and give you y+2*x. Otherwise it'll do multiple tree traversals internally. SymEngine doesn't have that option, but does only one traversal by default.

Also subs is inefficient because it is mathematically aware. (x+y+z).subs(x+y, 1) gives you z+1. xreplace on the other hand is not mathematically aware and relies on the structure. It takes in a dictionary and does the replacements simultaneously.

In [86]: (x + 2*y).subs([(x, y), (y, x)])
Out[86]: 3*x

In [87]: (x + 2*y).subs([(x, y), (y, x)], simultaneous=True)
Out[87]: 2*x + y

In [89]: (x + 2*y).xreplace({x: y, y: x})
Out[89]: 2*x + y

In [90]: (x+y+z).subs({x+y: 1})
Out[90]: z + 1

In [91]: (x+y+z).xreplace({x+y: 1})
Out[91]: x + y + z

EDIT: simultaneous=True also has multiple tree traversals.

Thanks for explaining!

!53 (merged)

mentioned in commit 2c566458

mentioned in merge request !54 (merged)

closed via commit 2c566458

closed via merge request !54 (merged)

closed via commit f52fefb5

mentioned in commit f52fefb5

I was trying to fix the expand(deep=True) in sympy and symengine and I was wondering what that should mean in an Add.

In a Mul, following is expected.

>>> expand(z*(x + (y+z)**2), deep=False)
z*x + z*(y + z)**2

In an Add, is following okay?

>>> expand(x + y*(x+z), deep=False)
x + y*(x+z)

Or the following,

>>> expand(x + y*(x+z), deep=False)
x + y*x + y*z

I think the goal is to distribute over the "first layer" of multiplication, no matter how deep it may be in the tree, but I am not sure. @inducer, can you give an example of how this is supposed to help the rscale code?