Week 4 and the final week of the first phase of the Coding Period is coming to an end. The work, which was initially proposed to be done in `FormalPowerSeries`

has been done on a term-by-term level, i.e. the operations which have been implemented return truncated terms of the resultant `FormalPowerSeries`

, instead of returning a `FormalPowerSeries`

object. Sartaj and I have already discussed about the `class`

implementation, in a recent meeting. Here are the deliverables which has been completed this week :–

- The PR #17017 consisted of a
`convolve`

function, which takes in a order`n`

term, and returns the truncated terms of the resultant convoluted formal power series. The`API`

of the`convolve`

function was in line with the`convolution`

function in`sympy.discrete.convolutions`

. More specifically, it was –`def convolve(self, other, x=None, n=6, cycle=0, dyadic=False, subset=False): """The logic of the code"""`

Sartaj suggested that there should be a

**method**kwarg, which can take in which`method`

of convolution the user wants to apply, instead of passing various kwargs representing the various methods. So I changed the`API`

of the function, in lines with the above comment. Currently it is –`def convolve(self, other, x=None, n=6, cycle=0, method=None): """The logic of the code"""`

in which method will be one of

`[dyadic, subset, None]`

, and cycle will represent the no. of cycles in cyclic convolution. Docs have also been updated. The PR is now in a mergeable state !! - I also opened a [PR #17064], which deals with the
`composition`

and`inversion`

of formal power series. I had implemented a`CoeffBell`

class, where essentially`CoeffBellCompose(f, n, k) represents Bell polynomials of the second kind`

. Note that both`n`

and`k`

should be integers. The implementation of the`eval`

function of the`CoeffBell`

class is as follows –`@classmethod def eval(cls, f, n, k): fp = fps(f) kv = fp.ak.variables[0] i = symbols('i') if n.is_integer and k.is_integer: fp_seq = sequence(fp.ak.formula, (kv, 1, n-k+1)) fact_seq = sequence(factorial(i), (i, 1, n-k+1)) bell_seq = fp_seq * fact_seq return bell(n, k, tuple(bell_seq))`

Then we can easily define bell sequences in terms of

`CoeffBell`

classes. Once we define them, all other terms can defined as sequences, and then the sequences can be multiplied and then the terms can be added up. Once we implement them, we can add up the sequence terms, and get the desired resultant truncated terms.

The various tests implemented here will give you an idea. They are :-

```
def test_fps__composition():
f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x))
raises(ValueError, lambda: f1.compose(sin(x), x))
raises(ValueError, lambda: f1.compose(fps(sin(x), dir=-1), x, 4))
raises(ValueError, lambda: f1.compose(fps(sin(x), x0=1), x, 4))
raises(ValueError, lambda: f1.compose(fps(sin(y)), x, 4))
raises(ValueError, lambda: f1.compose(f3, x))
raises(ValueError, lambda: f2.compose(f3, x))
assert f1.compose(f2, x) == 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6)
assert f1.compose(f2, x, n=4) == 1 + x + x**2/2 + O(x**4)
assert f1.compose(f2, x, n=8) == \
1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8)
assert f2.compose(f2, x, n=4) == x - x**3/6 + O(x**4)
assert f2.compose(f2, x, n=8) == x - x**3/6 + 11*x**5/120 - 127*x**7/5040 + O(x**8)
def test_fps__inverse():
f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x))
raises(ValueError, lambda: f1.inverse(x))
raises(ValueError, lambda: f1.inverse(x, n=8))
assert f2.inverse(x) == 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6)
assert f2.inverse(x, n=8) == \
1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + x**6/720 - x**7/5040 + O(x**8)
assert f3.inverse(x) == 1 + x**2/2 + 5*x**4/24 + O(x**6)
assert f3.inverse(x, n=8) == 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8)
```

- Now that these implementations are over with, I have to start thinking about how we can make FormalPowerSeries objects as a result of these functions, instead of returning only the truncated terms. The first step in doing that would be to make all the sequences infinite, and save whatever sequence can be saved. Then we can create a sub-class out of
`FormalPowerSeries`

, which can have a custom`_eval_terms`

function which, instead of calculating term by term, will calculate the addition of all terms together. Once we have the base`sub-class`

ready, we can then move forward with creating three sub-classes out of the sub-class, one each for`convolve`

,`compose`

, and`inverse`

. I will publish a PR, consisting of these changes, by the end of this week.

The first phase is over !! Phew !! See you in the next week. Adios till then !!