---
layout: post
title: GSoC Week 11
---

Sorry for the delayed post! Last week was extremely busy.

It's time to wrap up my work. The good new is that `rs_series` (I called it
`series_fast` earlier) works well for taylor series. The speedups are impressive
and it can handle all sorts of cases (so far!). Now, I need to make it work for
`laurent` and `puiseux` series.

Given that `ring_series` functions work well for negative and fractional powers,
ideally that shouldn't be difficult. However, my current strategy is to add
variables as generators to the currently used ring. The backend of creating
rings is in `polys`, which doesn't allow negative or fractional powers in the
generators (that is the mathematical definition of polynomials). For example:

```
In [276]: sring(a**QQ(2,3))
Out[276]: (Polynomial ring in a**(1/3) over ZZ with lex order, (a**(1/3))**2)

In [277]: _[0].gens
Out[277]: ((a**(1/3)),)
```

Contrast this with:
```
In [285]: sring(a**2)
Out[285]: (Polynomial ring in a over ZZ with lex order, a**2)
```

Generators with negative or fractional powers are treated as symbolic atoms and
not as some variable raised to some power. So these fractional powers will never
simplify with other generators with the same base.

The easy way to fix this is to modify `sring` but that would mean changing the
core polys. I am still looking for a better way out.

The polynomial wrappers [PR](https://github.com/sympy/symengine/pull/511) had
been lying dead for quite some time. It currently uses piranha's `hash_set` but
it needs to work on `unordered_set` when piranha is not available. I am adding
that [here](https://github.com/sympy/symengine/pull/578). It is mostly done,
except for `encode` and `decode` functions. Once the wrappers are in, I can
start porting `ring_series` functions.

### Next Week

* Make `rs_series` work for puiseux series.

* Complete polynomial wrappers.

* Port the low level `ring_series` functions.

Cheers!

Add post for week 11
Add post for week 11
