Sidhant Nagpal

Concluding GSoC 2018: SymPy

2018-08-14T00:00:00+00:00

This post summarises the work that I have done during GSoC for SymPy. The links to the Pull Requests are in chronological order under each header. For following the progress made during GSoC, see my weekly posts.

This summer has been a great learning experience and has helped me get a good exposure of test-driven development. I plan to actively review the work that has went into this project and continue contributing to SymPy. I am grateful to my mentors, Kalevi and Aaron for reviewing my work, giving me valuable suggestions, and being readily available for discussions.

Pull Requests

This is the list of merged Pull Requests.

Major Additions

sympy/sympy#14725: Add discrete module, and transforms sub-module including Fast Fourier Transform, Number Theoretic Transform, and include docstring, doctests, unit-tests.
sympy/sympy#14745: Add convolution sub-module including convolution_fft, convolution_ntt and a general method convolution for identifying the type of convolution and handling the cyclic convolution case, and include docstring, doctests, unit-tests.
sympy/sympy#14765: Implement Walsh Hadamard Transform and include doctests, unit-tests, docstring for the same.
sympy/sympy#14783: Implement convolution_fwht and add support for keyword dyadic in the general convolution method, and include docstring, doctests, unit-tests.
sympy/sympy#14816: Add a method linrec which allows evaluation of linear recurrences without obtaining closed form expressions, and include tests for the same.
sympy/sympy#14853: Implement Möbius Transform using Yate’s Dynamic Programming method while having subset keyword for flexibility of the implementation, and include docstring, doctests, unit-tests.
sympy/sympy#14878: Implement subset convolution and include docstring, doctests, unit-tests.
sympy/sympy#14928: Add covering product in convolutions sub-module and include docstring, doctests, unit-tests.
sympy/sympy#14954: Add intersecting product in convolutions sub-module and include docstring, doctests, unit-tests.

sympy/sympy#14969: Improve Sphinx docs for SymPy, use plural module names - convolutions and recurrences, refine the documentation for discrete module.
sympy/sympy#14994: Add reStructuredText file for discrete module for inclusion in Sphinx docs, which can be referred here.
sympy/sympy#15025: Refine discrete module to fix tests using floats instead of Rationals, adding warning about sequence size for fft and other improvements.

Additional Improvements

sympy/sympy#14712: Add .rewrite(exp) capability for instances of Pow and fix bugs in solvers module.
sympy/sympy#14907: Fix exception handling for factorial modulo and refine the signature for general convolution method.
sympy/sympy-bot#18: Fix the issue of incorrect links being referred in wiki by explicitly specifying the links instead of using relative paths.

Future Work

Adding a user-facing public method that internally calls discrete.recurrences.linrec and possibly extending it for different types of recurrences as well.
Making methods fft and convolution_fft efficient for both symbolic and numeric variants, as some discussion and benchmarking has been done for it and there is some work done by Colin for implementing a ComplexFloat class in sympy/sympy#12192 which would be very helpful for the same.

GSoC 2018: SymPy - Week 12

2018-08-07T00:00:00+00:00

The final week of Coding Period has completed.

This week, the work was mainly concerned with the documentation and refinements in the discrete module. I started by opening PR #14994 to update Sphinx docs for SymPy. Kalevi and Aaron were kind enough to review the PR and help refine it for the final merge. The documentation for discrete module is now part of the SymPy docs and can be referred here.

Late this week, I opened PR #15025 for improvements in the discrete module. Colin helped fix accidental floats in unit tests (which should have been Rationals). After the review, the PR was merged successfully.

Future work would include - addition of a user-facing public method for linrec and making methods fft and convolution_fft efficient for both symbolic and numeric variants, as some discussion and benchmarking has been done for it and there is some work done by Colin for ComplexFloat class in PR #12192 which would be helpful for the same.

Looking forward to the concluding phase, where I will be wrapping up GSoC and preparing the report for the final evaluation.

GSoC 2018: SymPy - Week 11

2018-07-28T00:00:00+00:00

This week, I started working on adding the final method to convolution module for Intersecting Product. PR #14954 dealt with the addition of intersection_product method. Intersecting Product was implemented using Möbius Transform with superset enumeration (mobius_transform(..., subset=False) and inverse_mobius_transform(..., subset=False)). After minor documentation improvements, the PR was merged successfully. The proposed transforms and convolutions are now part of sympy.discrete. The basic usage for the method is:

>>> from sympy import symbols, S, I, intersecting_product
>>> u, v, x, y, z = symbols('u v x y z')

>>> intersecting_product([u, v], [x, y])
[u*x + u*y + v*x, v*y]
>>> intersecting_product([u, v, x], [y, z])
[u*y + u*z + v*y + x*y + x*z, v*z, 0, 0]

Late this week, I started working on improving the documentation for SymPy’s Sphinx docs (http://docs.sympy.org/dev/index.html) and other minor changes in the PR #14969. Also, issue #14964 was opened to discuss the possibility of using LaTeX in docstrings for SymPy documentation. The following changes were part of the PR:

Use LaTeX for docstrings in functions.combinatorial (reference to #14964)
Include genocchi and partition numbers in sphinx docs
Improve docstrings with single and double backticks for sphinx docs
Use plural module names under discrete (discrete.convolutions and discrete.recurrences)
Add graphviz as a prerequisite in sympy/doc/README.rst for Debian/Ubuntu
Fix links in references containing rounded braces and unicode chars for sphinx docs
Miscellaneous improvements to documentation

Successive reviews and discussions were helpful in finalizing the Pull Requests.

Looking forward to the final week of Coding Period.

GSoC 2018: SymPy - Week 10

2018-07-21T00:00:00+00:00

This week SymPy 1.2 was released, which included the discrete module. The complete changelog for the SymPy 1.2 is here. I started the week by cleaning up discrete module, improving the API of public convolution method by attending to reviews by Aaron and Kalevi and fixing issue #14901 reported by Aaron in PR #14907.

The PR #14907 has been merged successfully and will be part of SymPy 1.2.1.

Late this week, I started working on the convolution module for inclusion of covering_product. The PR #14298 included the same with documentation, doctests and unit tests. The implementation of covering_product uses Möbius Transform with subset enumeration (mobius_transform(..., subset=True) and inverse_mobius_transform(..., subset=True)). As included in the PR, the usage for the same is:

>>> from sympy import symbols, covering_product
>>> u, v, x, y, z = symbols('u v x y z')

>>> covering_product([u, v], [x, y])
[u*x, u*y + v*x + v*y]

>>> covering_product([u, v, x], [y, z])
[u*y, u*z + v*y + v*z, x*y, x*z]

Looking forward to the next week, where I will be implementing intersecting_product as the final method for the convolution module.

GSoC 2018: SymPy - Week 9

2018-07-14T00:00:00+00:00

The second phase of Coding Period has concluded.

This week I worked on implementing Subset Convolution for discrete module. PR #14878 was opened for the same. The PR included unit tests, documentation, and correspondingly subset keyword was added for public convolution method.

After discussing the implementation details and references with Kalevi, the approach was finalized. The PR has been merged successfully. The usage for the same is:

>>> from sympy.discrete.convolutions import (convolution, convolution_subset)
>>> u, v, x, y, z = symbols('u v x y z')

>>> convolution_subset([u, v], [x, y])
[u*x, u*y + v*x]

>>> convolution([u, v, x], [y, z], subset=True)
[u*y, u*z + v*y, x*y, x*z]

>>> convolution([u, v, x], [y, z], subset=True, cycle=3)
[u*y + x*z, u*z + v*y, x*y]

Plan for this phase has executed well, and the second evaluation has been successful.

Looking forward to the final phase of Coding Period.

GSoC 2018: SymPy - Week 8

2018-07-06T00:00:00+00:00

This week I started working on adding Möbius Transform to the discrete module using Yate’s DP (Dynamic Programming) method for implementation as part of PR #14853. The proposed transforms are part of sympy.discrete.transforms module.

After discussing with Kalevi, the methods implementing this transform were added with appropriate names. The keyword subset is used as a boolean to choose whether enumeration is done over subsets or supersets. The usage for the transform is:

>>> from sympy import mobius_transform, inverse_mobius_transform
>>> seq = list(symbols('w x y z'))
>>> mobius_transform(seq)
[w, w + x, w + y, w + x + y + z]
>>> inverse_mobius_transform(_)
[w, x, y, z]
>>> inverse_mobius_transform(seq, subset=False)
[w - x - y + z, x - z, y - z, z]
>>> mobius_transform(_, subset=False)
[w, x, y, z]

The PR was merged successfully, after inclusion of docstring and unit tests for the transform.

Looking forward to another exciting week.

GSoC 2018: SymPy - Week 6 & 7

2018-06-28T00:00:00+00:00

The second phase of Coding Period has started.

I started this phase working on recurrence submodule under discrete. After having an initial discussion with Kalevi regarding the functionality to be implemented, I did the proof-of-concept for the same on a remote branch.

After the approach was finalized, the implementation was polished before opening the PR. The PR #14816 also included documentation, doctests, and unit tests for the module.

The method linrec(coeffs, init, n) takes coefficients, initial values and point of evaluation for the linear recurrence. Usage for a recurrence like f(n) = f(n - 7) + f(n - 13) + f(n - 17) (having order 17) would be:

In []: coeffs, init = [0]*17, [1]*17
In []: coeffs[7 - 1] = coeffs[13 - 1] = coeffs[17 - 1] = 1
In []: [linrec(coeffs, init, n) for n in range(40, 50)]
Out[]: [17, 21, 21, 23, 29, 31, 31, 35, 41, 41]

In []: def f(n):
  ...:     if n < 17:
  ...:         return 1
  ...:     return f(n - 7) + f(n - 13) + f(n - 17)
  ...:

In []: [f(n) for n in range(40, 50)]
Out[]: [17, 21, 21, 23, 29, 31, 31, 35, 41, 41]

As suggested by Aaron, it will be good to have a user-facing method that calls linrec internally for performing the computation.

Looking forward to another exciting week.

GSoC 2018: SymPy - Week 5

2018-06-15T00:00:00+00:00

The first phase of Coding Period has concluded.

This week, I started working on the convolution for -group using fwht - Dyadic (XOR) Convolution. The PR #14783 dealt with this addition to the module.

I had a useful discussion with Kalevi for clearing the API and naming convention.
The convolution method uses dyadic=True as the hint which uses convolution_fwht for the implementation. Appropriate documentation, doctests and unit tests are also included.

Successive reviews helped in refining the PR, before the final merge later in the week.

The usage for the same is:

>>> from sympy.discrete.convolutions import (convolution, convolution_fwht)
>>> from sympy import symbols
>>> u, v, x, y = symbols('u v x y')
>>> convolution([u, v], [x, y], dyadic=True)
[u*x + v*y, u*y + v*x]
>>> convolution_fwht([u, v], [x, y]) == _
True

Plan for this phase has executed according to the timeline, and the first evaluation has been successful.

Looking forward to the next phase of Coding Period.

GSoC 2018: SymPy - Week 4

2018-06-09T00:00:00+00:00

Another week of Coding Period has concluded.

Starting this week, I worked on PR #14765 for implementing Fast Walsh Hadamard Transform (fwht).

As pointed out by Kalevi, symbolic coefficients could be supported by this transform as the general Kronecker matrix only contains +/-1, which means it essentialy requires only addition or subtraction to perform the transformation. Also, the PR review helped fix a minor issue related to string concatenation.

Usage for fwht looks like:

>>> from sympy import fwht, ifwht, symbols
>>> fwht([4, 2, 2, 0, 0, 2, -2, 0])
[8, 0, 8, 0, 8, 8, 0, 0]
>>> ifwht(_)
[4, 2, 2, 0, 0, 2, -2, 0]

>>> a, b, c, d = symbols('a b c d')
>>> fwht([a, b, c, d])
[a + b + c + d, a - b + c - d, a + b - c - d, a - b - c + d]
>>> ifwht(_)
[a, b, c, d]

Documentation, doctests, and unit tests are also added for this transform.

Looking forward to next week, where I will be implementing XOR convolution using fwht.

GSoC 2018: SymPy - Week 3

2018-06-03T00:00:00+00:00

The third week of Coding Period has concluded.

I started the week by finalizing the PR #14745. The PR has been merged successfully. The master branch of sympy now contains transforms and convolution submodules under discrete. I have tested corner cases as well. Documentation and Doctests are complete for the transforms and types of convolution that are currently part of master.

Late this week, I pushed commits to PR #14712 with the aim of fixing failing tests in test_util.py and test_inequalities.py due to solveset. The remaining tests are failing as solvers can not currently solve the transcendental equations when rewritten in exponential form.

Looking forward to next week, where I will be working on the Fast Walsh Hadamard Transform (fwht).

GSoC 2018: SymPy - Week 2

2018-05-29T00:00:00+00:00

The second week of Coding Period has concluded.

I started the week by finalizing the PR #14725. The PR has been merged successfully. Fast Walsh Hadamard Transform (fwht) will be added along with XOR Convolution at a later point of time.

Late this week, I started working on the convolution module PR #14745 with the aim of adding the following along with appropriate tests.

Convolution using Fast Fourier Transform (convolution_fft)
Convolution using Number Theoretic Transform (convolution_ntt)
General Convolution method (convolution)

Kalevi and Aaron suggested using convolution as the name for the methods instead of conv. I had a detailed discussion with Kalevi regarding the API of the methods, the need to tie convolution with DFT (Discrete Fourier Transform), and handling the cyclic convolution case.

Successive reviews helped in the following changes to PR:

including cycle for general convolution method
usage of **hints argument in convolution for flexibility of the API
handling empty list [] cases
defaulting cycle=0 as normal convolution

Looking forward to another exciting week.

GSoC 2018: SymPy - Week 1

2018-05-23T00:00:00+00:00

The first week of Coding Period has concluded.

I started the week working on the PR #14712 to fix existing issues #14262 and #12744. There were some complications caused by the PR as it was affecting the solvers module. The failing tests on travis revealed some bugs and issues in solvers. The bugs are fixed, though minor issues still persist.

Late this week, I started working on the first PR #14725 as part of my project with the aim of adding the following along with appropriate tests.

Discrete Module
Transforms Module
Fast Fourier Transform (fft)
Number Theoretic Transform (ntt)
Fast Walsh Hadamard Transform (fwht)

Kalevi brought up an important point about complicated symbolic expressions when using fft. Aaron helped me fix a minor import issue.
Successive reviews helped in the following changes to PR:

using iterable(...) instead of hasattr(..., '__iter__')
adding doctests
improving documentation
fixing precision issues in fft using argument dps for decimal places or using unevaluated symbols in the first place (by passing dps=None)

Looking forward to another exciting week.

GSoC 2018: SymPy - Community Bonding

2018-05-16T00:00:00+00:00

The community bonding period has concluded. As proposed, I have gone through the existing modules and have thought about various aspects of the implementation which needed to be taken care of. The discussion for the project will take place on gitter under sympy/discrete.

Discussion for API is premature but it will shape as the Coding Period commences. Meanwhile, I have control of what all needs to be done in accordance with the proposed timeline.

Being familiar with the development workflow and having contributed to SymPy, I assisted new contributors and also helped review existing PRs - #14679, #14698 and #14707.

Looking forward to Coding Period.

Selected for GSoC 2018: SymPy

2018-04-24T00:00:00+00:00

I am extremely glad to inform that my proposal ‘Transforms, Convolution & Linear Recurrence Evaluation’ has been accepted by SymPy for Google Summer of Code 2018. For those unfamiliar, SymPy is a Computer Algebra System (CAS) written entirely in Python. SymPy was started as a project by Ondrej Certik (certik) in 2006. SymPy has participated in every Google Summer of Code since 2007.

My official mentors are Aaron Meurer (asmeurer) and Kalevi Suominen (jksuom). Aaron (who also joined from GSoC) is the lead developer of SymPy since 2011. Kalevi (SymPy Member) has mentored for Google Summer of Code in 2016 and 2017. I am extremely lucky to have gotten an opportunity to work with such experienced developers.

During the Community Bonding Period, I will complete the following tasks:

Setting up the blog with RSS feed for GSoC posts (for planet.sympy.org).
Discussing the possible modes of communication, and getting information for timings and weekly meetings.
Resolving any other issues that might arise during the Coding Period.
Getting the details for expected work to be done, discussing the API of the modules to be implemented and studying the existing modules which might be used.

I would like to thank the SymPy team, especially my mentors - Aaron Meurer and Kalevi Suominen.

Looking forward to a great summer.

Sidhant Nagpal

Concluding GSoC 2018: SymPy

Pull Requests

Major Additions

Documentation and Code Refinements

Additional Improvements

Future Work

GSoC 2018: SymPy - Week 12

GSoC 2018: SymPy - Week 11

GSoC 2018: SymPy - Week 10

GSoC 2018: SymPy - Week 9

GSoC 2018: SymPy - Week 8

GSoC 2018: SymPy - Week 6 & 7

GSoC 2018: SymPy - Week 5

GSoC 2018: SymPy - Week 4

GSoC 2018: SymPy - Week 3

GSoC 2018: SymPy - Week 2

GSoC 2018: SymPy - Week 1

GSoC 2018: SymPy - Community Bonding

Selected for GSoC 2018: SymPy