Sounds great.  Please post the slides (or if it is recorded, post  
that) after your presentation.  The abstract mentions that you will  
talk about how SymPy started, and I am interested in learning about  
that.

Otherwise, the favorite of mine from below is the sympyx core, because  
I will be unable to implement Constant as a fully automated class that  
does automatic simplification until we have handler logic in Add and  
Mul.  I imagine that it will have to wait until the new assumptions  
are in, because they will have to be integrated into whatever core we  
have (maybe we could get everything else from the sympyx core working  
and skip integrating new assumptions into the current core).  Until  
then, arbitrary constant simplification will have to just be  
implemented as a function.

It looks like the conference is right at the end of the Google Summer  
of Code program, so hopefully I will have some ODE stuff at least in  
the git repository by that point.  I already have several first order  
methods, though I plan on refactoring dsolve with a hints engine.  As  
for higher order equations, I should have at least variation of  
parameters working by then as well, and maybe more!

Aaron Meurer
On Jul 15, 2009, at 10:16 PM, Ondrej Certik wrote:

>
> Hi,
>
> SymPy was accepted both for the tutorial and a 40 min talk at the
> SciPy 2009 conference:
>
> http://conference.scipy.org/schedule
> http://conference.scipy.org/abstract?id=3
>
> I'll give the tutorial using sympy that is in all distributions/Sage,
> e.g. 0.6.4, or even older, like 0.6.2 in EPD. However, the conference
> is a good deadline to get some stuff done.
>
> The absolute number one priority is:
>
> * merge Fabian's assumptions branch and get rid of the old assumptions
>
> if we didn't manage nothing else, we have to manage this, it's very,
> very important.
>
> Then the other top priorities are:
>
> * merge the sympyx Python core
> * start using Cython in pure python mode (all around sympy)
> * merge Luke's trig branch (implements all kinds of simplifications to
> all 24 trig and inverse trig functions,
> sin/cos/tan/cot/sec/csc/asin/acos/atan/acot/asec/acsc, along with
> hyperbolic versions of each, just like Mathematica). I also hope we
> could implement some more advanced trig simplifications
> * port to Python 3.0
>
> And of course anything else, where you feel the most efficient. For
> example Aaron is doing excellent progress with the Constant class and
> ODE solvers. Chris just debugged a very nasty arithmetic
> simplification bug and fixed it (it's already committed).
>
> assumptions
> -----------------
>
> We'll start working on this with Fabian right after we release sympy
> 0.6.5 (hopefully tomorrow). Me and Fabian will put 100% of our efforts
> to make this succeed.
>
> sympyx
> -----------
>
> We did some work on that when Aaron visited me in Los Alamos and it
> seems it will allow to implement Order, infinity and other things
> outside the core, code is here (see also the handler branch):
>
> http://github.com/certik/sympyx
>
> python 3.0
> ---------------
>
> latest development on the python3.0 front is here:
>
> http://code.google.com/p/sympy/issues/detail?id=1262
>
> There doesn't seem to be any showstoppers now, just dozens of little
> things to fix. I believe anyone can finish it from this point on. :)
>
> Cython
> -----------
>
> As to Cython, I was just about to say "Cython is still not ready yet"
> when I noticed that Robert just fixed the showstopper bug:
>
> http://codespeak.net/pipermail/cython-dev/2009-July/006360.html
>
> I tested and it works! See here for a demo how the pure python mode
> works (see the README):
>
> http://github.com/certik/cython-test
>
> Now this is very exciting --- we can now use Cython to speed up
> critical parts of sympy and mpmath, and still remain pure Python. I
> plan to setup additional buildbots, that take sympy, runs cython on it
> and execute all tests. E.g. the same sympy tests will test both pure
> Python sympy, and cythonized sympy.
>
> Stuff like factorization of integers and similar things can be sped up
> very easily a lot. The ultimate goal of course is to cythonize the
> core classes, because they become  C structs and its virtually as fast
> as ginac, if done with care. The sympyx has it, but it will take some
> time to fully integrate it (it's easy to create a fast simple core,
> but way more challenging to add all the special cases, like
> assumptions, infinities, Order, ...). But we can (and will) start
> using cython here and there now, setup all the infrustructure and
> slowly start improving and experimenting with it. And then gradually
> improve.
>
> Ondrej
>
> >


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"sympy" group.
To post to this group, send email to sympy@googlegroups.com
To unsubscribe from this group, send email to sympy+unsubscr...@googlegroups.com
For more options, visit this group at http://groups.google.com/group/sympy?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to