gmane.comp.python.sympy

Re: atoms/xreplace idiom

Chris Smith — 2013-05-26T03:10:12

see reps_toposort in cse_main.

Re: atoms/xreplace idiom

Aaron Meurer — 2013-05-26T02:34:34

This has come up before actually. It would be useful to have a general
function that can topologically sort a list of expressions.

What would be the best way to have an ordered dict to use for xreplace
(given that OrderedDict is Python 2.7+ only)?

Aaron Meurer

On Sat, May 25, 2013 at 8:30 PM, Chris Smith <smichr-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: atoms/xreplace idiom

Chris Smith — 2013-05-26T01:30:15

I would do something like make a preprocess option that gets the
replacement dictionary in order and otherwise basically leave xreplace
alone.

Re: Google Code shutting down download service

Aaron Meurer — 2013-05-26T00:49:35

Actually, if PyPI works, let's just use that. If there become issues,
we can move somewhere else, but seeing as we have to upload to PyPI
anyway (or at least register there), keeping it as the sole download
location means one fewer step in our release process.

Aaron Meurer

On Sat, May 25, 2013 at 7:19 PM, Ondřej Čertík <ondrej.certik< at >gmail.com> wrote:

Re: Google Code shutting down download service

Ondřej Čertík — 2013-05-26T00:19:23

We can use pypi, but we can also use Source Forge (SF). I've been using SF
lately and it's not bad at all for hosting downloads, it has improved
a lot. They even have a landing page for Google Code:

https://sourceforge.net/publish/?source=googlecode

So they would be happy to take us.

Ondrej

Re: Google Code shutting down download service

Ondřej Čertík — 2013-05-25T23:46:17

We could put development tools into another repository. As to the doc directory,
we already ship it. And we would continue shipping the compiled docs separately.

Ondrej

Re: args invariant

Aaron Meurer — 2013-05-25T21:38:34

OK, sorry for not following this for a few days. I was busy moving to Austin.

A few points:

- I like Ronan's idea of putting the info in the func.  This is the
whole reason that we use expr.func instead of type(expr), so that we
can potentially make non-class head objects.   This idea also opens up
a lot of possiblities with
https://code.google.com/p/sympy/issues/detail?id=1688.

One comment on Ronan's reply, though: I don't see the point of
rebuild().  How is that different from func.__call__?  What are the
obstacles to making the head an object (or just using metaclasses,
though that can cause issues with things like pickling)?

- Regarding Symbol being Expr, this is orthogonal to this discussion.
I agree it is an issue for using it as a name, and that Symbol really
should have a more generic Basic superclass (this comes up with using
Symbol for booleans already, see
https://code.google.com/p/sympy/issues/detail?id=1887#c26).

- I agree that we should reuse common traversal patterns as named
functions.

Integral steps in SymPy Gamma

Aaron Meurer — 2013-05-25T20:24:00

I just merged David Li's pull request
https://github.com/sympy/sympy_gamma/pull/11 which adds integral and
derivative steps to SymPy Gamma.  This is inspired by a WolframAlpha
feature, which is now not available unless you pay.

Some examples

http://www.sympygamma.com/input/?i=diff%28x%2Aexp%28x%2A%2A3%29%2C%20x%29#diffsteps
http://www.sympygamma.com/input/?i=integrate%28sin%28x%29*exp%28x%29%2C+x%29#intsteps

By the way, the url for SymPy Gamma has changed to sympygamma.com.

Aaron Meurer

Re: Google Code shutting down download service

Aaron Meurer — 2013-05-25T19:53:23

This is different than the tarball created by setup.py sdist.  This
just tars up the contents of the git repository, which includes a
bunch of stuff that we don't include (and don't want to include) with
the tarball (mostly development tools; also, we ship our docs
separately).

Aaron Meurer

On Sat, May 25, 2013 at 2:43 PM,  <hacman0-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: Google Code shutting down download service

2013-05-25T19:43:32

Also, for tarballs, you can link directly to the git commit (via the tag name if it exists, which it does for releases). Like so:

https://github.com/sympy/sympy/archive/sympy-0.7.2.tar.gz

They support .zip as well (maybe even .tar.bz2).

Re: atoms/xreplace idiom

Aaron Meurer — 2013-05-25T18:39:13

Also, if we make this change, what should the behavior be? If we have

repl_dict = {sin(x): sin(sin(x))}
sin(x).xreplace(repl_dict)

What should it return? Naive nesting leads to recursion error.

Aaron Meurer


On Sat, May 25, 2013 at 1:25 PM, Aaron Meurer <asmeurer-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: atoms/xreplace idiom

Aaron Meurer — 2013-05-25T18:25:37

Yes, I know about subs and replace. I am writing a document about
low-level type expression manipulations, where you want to avoid any
intelligence ((x - 1).subs(x - 2, y)), and basically only replace
things based on the expression tree, not mathematically.  I lumped
replace into the category of subs, because it does smart things
(pattern matching and so on).

atoms and xreplace complement each other perfectly.  atoms only gives
exact subexpressions, and xreplace only replaces exact subexpressions.
 The things that xreplace will replace and the things that atoms will
give are exactly the same. Of course, they can be replaced with the
mathematically intelligent versions find and subs, but then the
relationship between those two sets is unclear.

On Sat, May 25, 2013 at 1:55 AM, Chris Smith <smichr-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

It doesn't stop processing. The issue is that it doesn't process nodes
that it replaces.  My example gives -cos(z) + cos(x + sin(y)).  Two of
the sines are replaced w

Re: Google Code shutting down download service

Stefan Krastanov — 2013-05-25T17:07:29

Now I feel stupid :)

Re: Google Code shutting down download service

Aaron Meurer — 2013-05-25T16:49:01

We could also just use PyPI.

Aaron Meurer

On May 25, 2013, at 7:40 AM, Stefan Krastanov
<krastanov.stefan-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: Find derivatives in expressions

Chris Smith — 2013-05-25T15:18:32

works for me (but I don't think you want f.func) and note that by using f
as the iteration variable you loose it as the function if you should try to
rebuild A:

set([Derivative(g(x), x)])
[<class 'sympy.core.function.Derivative'>]

Find derivatives in expressions

Alan Bromborsky — 2013-05-25T14:45:55

Consider a sympy expression

F = a*f+b*dg

where f = Function('f')(x), g = Function('g')(x), dg = g.diff(x)

then [f.func for f in A.atoms(Function)]  returns [f]

but [f.func for f in A.atoms(Derivative)] does not return [dg]

how do I get a list of the derivatives in F?

Re: Google Code shutting down download service

Stefan Krastanov — 2013-05-25T12:40:29

One of the messages dropped from the mailing list thread (it is below).

While there is no dedicated downloads page (it was deprecated, see
[1]), I think there is nothing stopping us from using github pages and
manually preparing the downloads as static pages (which is what we
were doing with google code). Besides maybe their TOS.

[1] https://github.com/blog/1302-goodbye-uploads

On 25 May 2013 13:37, Vinzent Steinberg <vinzent.steinberg-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: Google Code shutting down download service

Stefan Krastanov — 2013-05-25T10:49:47

What about github pages? Or is it against their TOS?

On 25 May 2013 12:34, Vinzent Steinberg <vinzent.steinberg-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Google Code shutting down download service

Vinzent Steinberg — 2013-05-25T10:34:06

It will be no longer possible to create new downloads on Google Code 
starting on January 15, 2014 [1].
(Google suggests to move to Google Drive.)

That means for sympy that new tarballs and Windows binaries will have to be 
hosted somewhere else.
(Old downloads remain accessible.)

Vinzent


[1] 
http://google-opensource.blogspot.de/2013/05/a-change-to-google-code-download-service.html

Re: atoms/xreplace idiom

Chris Smith — 2013-05-25T06:55:31

subs, replace and xreplace all have different strengths. If you are only
changing the function then replace is your ticket:

sin(y) + sin(y + sin(x))
cos(y) + cos(y + cos(x))

xreplace already does a top down but it stops processing when it hits the
first change as you found.

As to modifying what you are doing, maybe this:

...   for j in range(i + 1, len(r)):
...     r[j] = r[j][0], r[j][1].xreplace({ci[0]:ci[1]})
...
sin(y) + sin(y + sin(x))

atoms/xreplace idiom

Aaron Meurer — 2013-05-25T02:16:54

I'm writing about the atoms/xreplace idiom in the new tutorial.  How
would you go about using atoms and xreplace to replace all instances
of something in an expression?  For example, replace all instances of
sin with cos. The way I initially said to do it was like this

sin_atoms = expr.atoms(sin)
repl_dict = {s:cos(s.args[0]) for s in sin_atoms}
expr.xreplace(repl_dict)

But this does not work on nested expressions.  For example with
sin(sin(x) + y) + sin(y), you get cos(sin(x) + y) + cos(y).

Should xreplace be modified to do a top-down replacement, so that this
works? If not, what is the most elegant (and efficient) way to modify
my algorithm so that it works?  Should this idiom be something else
completely?

Aaron Meurer