Hi All,
I would like to work on extending the elementary functions module for
CSymPy this summer
as a GSoC project. I would like to focus mainly on implementing functions
on Combinatorial Number Theory.
These mainly include the functions which are currently implemented in
combinatorial module of SymPy.
I hope to implement following (rough) list of things related to
combinatorial number theory:
1. Functions corresponding to the factorial module in SymPy:
1. Factorial*
2. SubFactorial
3. Rising Factorial
4. Falling Factorial
5. Factorial2*
6. Multifactorial*
7. Binomial Coefficient*
2. Some Special Numbers from those implemented in numbers module in SymPy
1. Fibonacci*
2. Lucas*
3. Bernoulli
4. Catalan
Currently we are using gmp library in CSymPy. Some of whose functions have
been used in the ntheory module for CSymPy by Thilina.
>From the above list, the items marked (*) have already been implemented in
the Ntheory module of GMP [1]
I haven't yet decided upon the scope of the project. If the current amount
of work seems on the pessimist side,
I can include a couple of more Special Numbers implemented by SymPy and
then plan my timeline accordingly.
As far as implementing Bernoulli number is concerned, I have looked into
the bernmm[2] which has been authored
solely for computing Bernoulli numbers efficiently. It is also being used
in sage[5] to implement `bernoulli` function.
The dependencies of bernmm include GMP[3] (which is already being used as a
dependency) and NLT[4]
We can either look into reusing the same code, in such a scenario I can
find some more time to implement
some other combinatorial numbers or else we can look into implementing the
algorithm[6] itself.
I have created a very rough draft of the my proposal:
https://github.com/sympy/sympy/wiki/GSoC-2014-Application-Sushant-Hiray:-Extending-Elementary-Functions-CSymPy
Currently I'm trying to figure out the scope of the project, I would then
update the implementation issues and timeline accordingly.
Also as far as implementation is concerned, I'm following the route taken
by Thilina by creating
functions corresponding to each Combinatorial Number.
An alternate implementation might be to create a class corresponding to
each Combinatorial Number.
Using the latter method, we could add more functions later on
for eg:
risingfactorial(x,5) = x*(x+1)*(x+2)*(x+3)*(x+4)
In such a case, we can as well define the derivative, integral as the
library improves in the later stages.
So for such cases we might as well implement an eval function inside the
class which could evaluate its value
rather than just having it as a function which evaluates its value.
As far as proposal is concerned, I have followed the former method, but I
would like to hear suggestions regarding this.
Hoping to hear some feedback from you guys.
[1]
https://gmplib.org/manual/Number-Theoretic-Functions.html#Number-Theoretic-Functions
[2] http://web.maths.unsw.edu.au/~davidharvey/code/bernmm/
[3] https://gmplib.org/
[4] http://www.shoup.net/ntl/
[5] http://www.sagemath.org/
[6] http://web.maths.unsw.edu.au/~davidharvey/papers/bernmm/
Regards,
Sushant Hiray
--
You received this message because you are subscribed to the Google Groups
"sympy" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/sympy.
To view this discussion on the web visit
https://groups.google.com/d/msgid/sympy/7a391d3f-898d-462d-9e25-167f568ce5e3%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
