Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.Sign up
GSoC 2016 Application : Haskell Bindings to SymPy Engine
Clone this wiki locally
Create Haskell bindings for
SymEngine by extending and wrapping the C FFI layer of
Name: Siddharth Bhat
University: Manipal Institute of Technology, 4th semester, Computer Science Undergraduate
#rust at freenode
Other contact methods: Skype -
Country of residence: India
Timezone: IST (GMT +5:30)
Primary language: English
I'm 19 years old, going to turn 20 on 10th July.
I enjoy math and programming immensely, math more than programming a lot of the time. I like the elegance of pure math, and I try to find programming languages that reflect that. I'd say Haskell, Rust and Python achieve that state of zen in wildly different ways.
I play the piano as a hobby, and I've been trying to pick up the guitar. Cooking is something else that I love to do as well, though I'm not great at it.
Me as a Programmer
I'm currently using Mac OS X, but I used to run ArchLinux. I still own Kali Linux and Windows 10, though they're not my daily drivers.
I switch between a bunch of them depending on what I'm doing:
If it's Python, then I generally use PyCharm / Sublime Text
If it's C++, then Vim with YouCompleteMe.
General text editing is again mostly Vim
I contribute to a decent number of projects on Github, so
git is something I use everyday.
As for shells, I use
ag(silver searcher) over
grep due to
For one-off shell scripts, I tend to write Python scripts, or use Haskell's turtle library for "shell" scripting.
Stuff I've contributed to
PSSSPP - A PSP Emulator
I wrote a decent amount of code for PPSSPP, mainly related to the touch screen controls and
I programmed for VisPy during GSoC 2015 (and I still continue to work on it). My project was to rewrite a large chunk of code with one of the mentors to improve performance and provide flexibility to future versions of VisPy, and to integrate Cassowary into VisPy for nice-looking plots.
I have random commits into different Haskell projects. None of them are large enough to write about, but they're small housekeeping stuff I took up while learning the language.
I also hang out on the Haskell IRC as
bollu to answer questions and learn stuff.
I have contributed to the Rust ecosystem here-and-there, reporting compiler bugs and sending PR's to a couple of Rust packages.
I was also a member of Piston Developers, a group of Rust programmers who are trying to experiment with different game engine architectures in Rust.
Python and me.
I like the terse and yet expressive nature of python, and I dislike it for the exact same reason.
Python has brilliantly written libraries, and feels very natural to use in a
things like data exploration and web programming (and attacking).
One of the coolest things I've done in Python was to probably SQL inject databases during Microsoft's Build the Shield competition to access a 20-character long password.
Python's ability for higher-order-functions and the awesome
requests library saved the day.
Most advanced feature I've used
I've probably used most Python features here-and-there:
generators, even creating objects
on-the-fly, and other weird things. I prefer to stick to simple code though, since it aids comprehension
for everyone involved.
Some of the most advanced standard library features might be stuff like
multiprocessing to parallelise an
attack on a particular server, and
pickle to serialise data.
Cool python trick I like:
# transpose a 2-d list with a zip x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] x_transpose = list(zip(*x))
Stuff I dislike about python
Python sometimes has "too much magic", and I've submitted pull requests to actually reduce the amount of action-at-a-distance that Python allows.
Example PR to reduce magic: don't walk the module tree to create custom objects at import time.
The lack of types is a huge pain point as well, and is the reason I've been gravitating towards languages with strong type systems like Rust and Haskell in the recent past.
[TODO: Need to fill this up]
Stuff I've created
I've written a sublime text plugin called SublimeBookmarks to manage bookmarks in Sublime Text.
There's another tool called teleport, to manage directories of projects.
Unfortunately, this one is much rougher around the edges both due to Haskell's own limitations in distribution, and due to my schedule that didn't let me polish it. I do plan on coming back to this and showing it some love over the summer.
I've started many toy language projects, though none of them are complete. In no real order:
Achilles - Rust implementation a toy programming language of my own called "achilles". It was going to be functional, with heavy inspiration from Haskell. Rust's closure + lifetime interaction problems during beta made me give this one up.
cellular Automata - A collection of cellular automata written in Haskell. This is written so it's more of a library than an executable, though it does contain sample cellular automata. The goal was to make pretty GIF's with a neat API (using commands).
Me and my project
The goal of the project is to create well formed Haskell bindings from
SymPyEngine to Haskell. As of now,
SymPyEngine is a subset of
SymPy (in terms of feature set), and does not have
SymPy running on it yet, though that is in the roadmap.
SymPyEngine's existence is crucial because it allows for a C++ compiled codebase for symbolic computation, which is much faster than Python, and is also much more portable (most languages have C/C++ FFI bindings).
Why this project?
I'd love to do this for two reasons:
I like math, and I'm sure that by spelunking the SymPyEngine codebase, I'll pick up some amount of math / algorithms / optimization lore by osmosis. So that makes the project "fun" as a whole
I'd get to push Haskell's story of symbolic mathematics, something that is somewhat lacking right now as agreed upon by the Haskell community.
SymPybindings would be huge since the toolkit is mature, and would encourage a lot of interesting code in Haskell.
I have some selfish interest in this as well - I wanted to create really slick visualisations for my blog in relation to Group Theory (since I find the subject beautiful). Haskell has a brilliant library for visualisations called diagrams.
However, it lacks a proper library for symbolic math. Getting this into Haskell would mean cooler libraries to use and better data visualisation for me :)
I've written a decent amount of Haskell, C, and Python code in my past. This project needs all 3 of
those languages - C for the FFI, Haskell for the Haskell bindings, Python to look at the Cython
wrappers and read
SymPy code in general.
I also understand pure math (I've taken analysis, algebra and topology, though I know more algebra than the other two branches of math), so I won't get "lost" in the docs so to speak.
Stuff to Do
Approaches for implementation
Operator Overloading for
One way to implement "operator overloading" is to simply construct new operators.
One of the neatest approaches is to create pairs of operators like so:
(.+) :: Num a -> Symbol -> Symbol (+.) :: Num a -> Symbol -> Symbol
that allow adding a
Num instance and a
Symbol instance together.
Another design approach is to have a custom typeclass that can be added together using
a new custom operator, say
class SymbolOperations where <+> :: SymbolOperations a -> SymbolOperations a -> SymbolOperations a instance (Num a) => SymbolOperations a where ... instance SymbolOperations Symbol where ...
this approach is "neater" in the sense that it just needs one operator, but the typeclass feels like a hack since it doesn't really impose any laws. I'm okay with both approaches.
Past work in the same area
I'll be dedicating 8 hours a day, hopefully every day. It'll probably be a little less during weekends, but not a drastic drop in productivity. That brings it to ~50 hours a week, give or take.
As far as I am aware, This has not been done in the past, so there is no real "reference" implementation to go to.
Google's rough timeline
23 May: Students begin coding for their Google Summer of Code projects; Google begins issuing initial student payments provided tax forms are on file and students are in good standing with their communities. Work Period Mentors give students a helping hand and guidance on their projects.
20 June 19:00 UTC: Mentors and students can begin submitting mid-term evaluations.
27 June 19:00 UTC: Mid-term evaluations deadline; Google begins issuing mid-term student payments provided passing student survey is on file. Work Period Mentors give students a helping hand and guidance on their projects.
15 August - 23 August 19:00 UTC Final week: Students tidy code, write tests, improve documentation and submit their code sample. Students also submit their final mentor evaluation.
My timeline breakdown
Week 1, 2 - [23 May to 6 June]
Work on finishing simple operations supported currently by
crwapper.hwhich is the basic C FFI layer to the C++ codebase.
QuickCheckchecking for the Haskell codebase, which provides automated testing given invariants. This ensures that there is a proper test framework in place to prevent regressions.
Week 3, 4 - [6 June to 20 June]
Export symbols from
symbol.hwhich represents basic symbolic manipuation.
Export Integers from
Export Rationals form
Export Complex numbers from
Exporting these types will allow us to have the basic numeric tower for math computation.
Export trignometric, hyperbolic trig functions from
functions.hsubmodule of SymEngine for trig support.
Export basic functions (
abs, etc.) from
Week 5 - [20 June to 27 June] Mid term Evaluation prep
Export special functions (
Levi-Civita, etc) functions from
0.2.0.0of the package version to
Hackage, which is the Haskell community's open source package repository.
Since the package will be decently feature-complete, get the package onto
Stackage, which is where stable, community-curated packages live.
27 June - Mid term Evaluation
Week 6, 7 - [27 June to 11 July]
Lambdifyimplementation for Haskell (convert from SymPy expressions to a proper Haskell function that can be used for computation). This will be restricted to simple functions as a starting point. (trig, basic functions, special functions will work.)
Week 8, 9 - [11 July to 25 July]
- Implement numerical evaluation functions from
Week 10, 11 - [25 July - 8 August]
Implement polynomials FFI into
Create Haskell bindings for
Implement Matrix FFI from
Create Haskell bindings for
Write tests cases (for both the C FFI side and the Haskell side), library documentation for the above classes.
Week 12, 13 - [8 August - 22 August] Final Evaluation prep
Complete documentation of libraries and codebase, get code reviews from the Haskell community (e.g.
ekemett(Edward Kmett, a prolific Haskell contributor who is almost always on IRC and helps with Haskell code))
Upload package version
Get stable package version into
Upload posts to
23 August - Final Evaluation
IHaskell's support for rich data visualisation to render objects such as polynomials and matrices using
IHaskellGithub page describes how this can be supported