Like I said in my last post, this was my first week in college after summer
vacation. I had to reschedule my daily work according to my class timings (which
are pretty arbitrary). Anyway, since I do not have a test anytime soon, things
were manageable.

#### So Far

##### Ring Series

This week I worked on `rs_series`

in PR 9614.
As Donald Knuth succinctly said, 'Premature optimisation is the root of all
evil', my first goal was to write a function that used `ring_series`

to expand
`Basic`

expressions and worked in all cases. That has been achieved. The new
function is considerably faster than SymPy's `series`

in most cases. eg.

```
In [9]: %timeit rs_series(sin(a)*cos(a) - exp(a**2*b),a,10)
10 loops, best of 3: 46.7 ms per loop
In [10]: %timeit (sin(a)*cos(a) - exp(a**2*b)).series(a,0,10)
1 loops, best of 3: 1.08 s per loop
```

However, in many cases the speed advantage is not enough, especially considering
that all elementary `ring_series`

functions are faster than SymPy's series
functions by factors of 20-100. Consider:

```
In [20]: q
Out[20]: (exp(a*b) + sin(a))*(exp(a**2 + a) + sin(a))*(sin(a) + cos(a))
In [21]: %timeit q.series(a,0,10)
1 loops, best of 3: 2.81 s per loop
In [22]: %timeit rs_series(q,a,10)
1 loops, best of 3: 3.99 s per loop
```

In this case, `rs_series`

is in fact slower than the current `series`

method!.
This means that `rs_series`

needs to be optimised, as expanding the same
expression directly with `rs_*`

functions is much faster.

```
In [23]: %timeit (rs_exp(x*y,x,10) + rs_sin(x,x,10))*(rs_exp(x**2+ x,x,10) + rs_sin(x,x,10))*(rs_sin(x,x,10) + rs_cos(x,x,10))
1 loops, best of 3: 217 ms per loop
```

I spent Friday playing with `rs_series`

. Since the function is recursive, I even
tried using a functional approach (with map, reduce, partial, etc). It was fun
exploring SymPy's functional capabilities (which are quite decent, though
Haskell's syntax is of course more natural). This didn't make much difference in
speed. Code profiling revealed that `rs_series`

is making too many function
calls (which is expected). So, I plan to try a non-recursive approach to see if
that makes much of a difference. Other than that, I will also try to make it
smarter so that it does not go through needless iterations (which it currently
does in many cases).

##### SymEngine

I had a discussion with Sumith about Polynomial wrappers. I am helping him
with constructors and multiplication. We both want the basic `Polynomial`

class
done as soon as possible, so that I can start with writing series expansion of
functions using it.

I also sent a PR 562 that adds C
wrappers for `Complex`

class. This will be especially helpful for Ruby wrappers
that Abinash is working on. FQA
is a nice place to read about writing C++/C wrappers and for some side
entertainment too.

Other than that, I also happened to have a discussion with
Harsh on the new solve-set he and
Amit are working on. Their basic idea is that you
always work with sets (input and output) and that the user can choose what
domain he wants to work on. The latter idea is quite similar to what SymPy's `polys`

does. Needless to say, their approach is much more powerful that `solvers`

's. I
will be working with them.

#### Next Week

Targets for the next week are as modest as they are crucial:

Cheers!