I spent a good amount of time this week trying to make the series function more
intelligent about which
ring it operates on. The earlier strategy of using the
EX ring proved to be slow in many cases. I had discussions with Kalevi
Suominen, who is a developer at SymPy and we figured
out the following strategy:
The user inputs a Basic
expr. We use
sringover QQ to get the starting ring.
We call individual functions by recursing on
exprhas a constant term we create a new ring with additional generators required by the ring (e.g sin and cos in case of
This means that each
ring_seriesfunction now can add generators to the ring it gets so that it can expand the expression.
This results in considerable speed-up as we do operations on the simplest
possible ring as opposed to using
EX which is the most complex (and hence
slowest) ring. Because of this, the time taken by the
series_fast function in
marginally more than direct function calls. The function doesn't yet have code
for handling arbitrary expressions, which will add some overhead of its own.
Most of the extra time is taken by
sring. The overhead is constant, however (for
a given expression). So for
series_fast(sin(a**2 + a*b), a, 10) the extra
routines take about 50% of the total time (the function is 2-4 x slower). For
series_fast(sin(a**2 + a*b), a, 100), they take 2% of the total time and the
function is almost as fast as on
There is, of course scope for speedup in
sring (as mentioned in its file).
Another option is to minimise the number of calls to
sring, if possible to
just one (in the
In my last post I talked about the new
solveset module that
Harsh and Amit are
working on. I am working with them and I sent a
patch to add a
domain argument to
solveset function. It is pretty cool stuff in that solution is always
guaranteed to be complete.
I haven't been yet been able to start porting the code to Symengine as the
Polynomial wrappers are not yet ready. Hopefully, they should be done by the next
week. Till, then I will focus on improving
series_fast and any interesting
issues that come my way.
Write a fully functional
series_fast. Profile it properly and optimise it.
Document the functions and algorithms used in