Some ideas for GSoC
Aaron Meurer
I wanted to get some feedback from the community on some ideas I had
for Google Summer of Code projects. For the following ideas, I want
to know if you
- think that it is within the scope of the SymPy project enough for us
to support it,
- think that it is doable as a GSoC project (i.e., it isn't too much
or too little work to complete over a summer), and
- are able to mentor it, or think that we can find someone who can.
For some of these, I'm pretty sure that if we put them on our ideas
list that there's a high chance that we will get proposals to do them,
which is why I'm asking here about them first.
Here are my ideas:
1. Some of you may have noticed that WolframAlpha recently released a
big update. You can now pay them and get a bunch of features. They
also do things like save your search history.
Our competition to WolframAlpha is SymPy Live
(http://live.sympy.org/). Also, a while back, Ondrej whipped up a
thing called SymPy Gamma (http://gamma.sympy.org/), which is a little
closer to WolframAlpha.
The GSoC project would be to improve one or both of these things.
SymPy Gamma could be improved a lot, by making it more intelligent
about what output it produces for different inputs, making it parse
expressions that aren't given in exact SymPy syntax, making it produce
plots, perhaps replacing the notebook with an IPython notebook. SymPy
Live could use a lot of the same features.
2. Write a mobile app for Android and/or iOS. Other app developers
have already demonstrated that it's possible to run SymPy natively on
both of these operating systems. The project would be to write an app
that gives a nice interface to it. One thing that could be done would
be to make a soft keyboard that is conducive to math input (similar to
what WolframAlpha has for their mobile apps). If there are issues
with running SymPy on the device itself, we could make the app to just
be a nice interface to SymPy Live/Gamma.
My main concern with this project is mentors. I don't feel that I
know C, Objective-C, Java well enough to mentor a student doing this.
Does anyone here feel that they do?
3. Some kind of equation editor. This idea is still vague. It could
be considered part of a mobile app interface, part of a potential
desktop app interface, or even a terminal curses interface. I just
feel that more users would be attracted to SymPy if it had some kind
of 2d equation editing capabilities.
I'm also interested how you feel about whether or not this fits within
the scope of the SymPy project. Most of this wouldn't involve any
changes to SymPy itself, other than bug fixes (though things like
improved parsing for SymPy Gamma would go there). I personally feel
that they do, especially the first two, and that their existence would
greatly help expand SymPy's user base, but I think that the community
should decide.
Aaron Meurer
Tom Bachmann
> 2. Write a mobile app for Android and/or iOS. Other app developers
> have already demonstrated that it's possible to run SymPy natively on
> both of these operating systems. The project would be to write an app
> that gives a nice interface to it. One thing that could be done would
> be to make a soft keyboard that is conducive to math input (similar to
> what WolframAlpha has for their mobile apps). If there are issues
> with running SymPy on the device itself, we could make the app to just
> be a nice interface to SymPy Live/Gamma.
>
> My main concern with this project is mentors. I don't feel that I
> know C, Objective-C, Java well enough to mentor a student doing this.
> Does anyone here feel that they do?
>
My plans for the summer are not at all finalised enough to tell if I am
going to be able to mentor (or if I even want to apply myself again!),
but if so I would be happy to mentor this project. (My knowledge of C,
C++ and Java is certainly better than that of python...)
Roberto Colistete Jr.
Hi everyone. 2. Write a mobile app for Android and/or iOS. Other app developers have already demonstrated that it's possible to run SymPy natively on both of these operating systems. The project would be to write an app that gives a nice interface to it. One thing that could be done would be to make a soft keyboard that is conducive to math input (similar to what WolframAlpha has for their mobile apps). If there are issues with running SymPy on the device itself, we could make the app to just be a nice interface to SymPy Live/Gamma. My main concern with this project is mentors. I don't feel that I know C, Objective-C, Java well enough to mentor a student doing this. Does anyone here feel that they do?
Hi,
About the 2o proposition above :
- Android OS has a good Python (in Scripting Layer For Android - SL4A) implementation, so it is indeed possible to create a SymPy GUI using Python on Android. We currently have 3 options of GUI programming in Python SL4A :
* UiFacade, but its restricted to dialog windows, not full screen :
http://code.google.com/p/android-scripting/wiki/ApiReference
* webview (Python + HTML/CSS + JavaScript), allowing full screen GUI :
http://code.google.com/p/android-scripting/wiki/UsingWebView
My Python webview template (with commented source-code) :
http://www.robertocolistete.net/Python/Android/
More complex software, SMSSender, using Python SL4A & webview :
http://android-scripting.blogspot.com/2010/11/sms-merger-reviewed-with.html
* FullScreenUI experimental, it needs sl4a_r5x (beta), but it is not finished :
http://code.google.com/p/android-scripting/wiki/FullScreenUI
- there are good virtual keyboards on Android, e.g. "Hacker's keyboard" is free and good for mathematical typing. So, maybe, a specific keyboard is not needed;
- if you accept, I can be a mentor and I have a possible student candidate for GSoC 2012, with a project restricted to making a SymPy GUI for Android using Python/SL4A. Using webview or FullScreenUI (if it improves in the following months). Possible names of this software : SymPyMath or EaSymPy ;-) ?
I am totally interested in programming&scientific softwares for smartphones&tablets. I have elected Python because of its availability and portability across diferent mobile OS :
- See my conclusions in "SymPy for smartphones & tablets" web site :
http://www.robertocolistete.net/Python/SymPy/
- I am the author of Integral, Derivative and Limit for Maemo 4 & 5 OS, all using SymPy and Python/Qt, with between 31-43 thousand downloads for each one. There are MeeGo Harmattan (Nokia N9), Symbian and Android versions in development;
- I am maintainer of SymPy for Maemo 4 & 5 and MeeGo 1.2 Harmattan, as well as other Python modules.
Regards from Brazil,
Roberto Colistete Jr.
Aaron Meurer
Good point. Likely there are some good open source keyboard libraries
for iOS as well. Hacker's keyboard is licensed under Apache
(http://code.google.com/p/hackerskeyboard/), which from what I
understand is compatible with BSD, assuming you include some NOTICE
files (http://en.wikipedia.org/wiki/Apache_License). No doubt there
are other libraries as well.
My idea was to have some default keyboard, but to allow users to
create their own custom keyboards. On each key could be put some
custom characters, and the key could be assigned to run a Python
script on the input, allowing pretty advanced possibilities. We could
then have some library where people could upload their keyboards and
download others, and vote on them etc. We could even take some of the
better ideas and integrate them into the app itself.
And even if the keyboard ends up being trivial, I've got plenty of
ideas to keep a student busy: plotting, a custom tutorial for the
mobile version, IPython integration (including support for tab
completion), the ability to download and use the git version of SymPy,
and the list goes on.
Aaron Meurer
>
> - if you accept, I can be a mentor and I have a possible student candidate
> for GSoC 2012, with a project restricted to making a SymPy GUI for Android
> using Python/SL4A. Using webview or FullScreenUI (if it improves in the
> following months). Possible names of this software : SymPyMath or EaSymPy
> ;-) ?
>
> I am totally interested in programming&scientific softwares for
> smartphones&tablets. I have elected Python because of its availability and
> portability across diferent mobile OS :
> - See my conclusions in "SymPy for smartphones & tablets" web site :
> http://www.robertocolistete.net/Python/SymPy/
> - I am the author of Integral, Derivative and Limit for Maemo 4 & 5 OS, all
> using SymPy and Python/Qt, with between 31-43 thousand downloads for each
> one. There are MeeGo Harmattan (Nokia N9), Symbian and Android versions in
> development;
> - I am maintainer of SymPy for Maemo 4 & 5 and MeeGo 1.2 Harmattan, as well
> as other Python modules.
>
> Regards from Brazil,
>
> Roberto Colistete Jr.
>
> --
> You received this message because you are subscribed to the Google Groups
> "sympy" group.
> To post to this group, send email to sy...@googlegroups.com.
> To unsubscribe from this group, send email to
> sympy+un...@googlegroups.com.
> For more options, visit this group at
> http://groups.google.com/group/sympy?hl=en.
beast11
dependent on WolframAlpha.
Can anyone suggest me how to apply for the project here under SymPy
i.e what details and format of the proposal and etcetera?
Aaron Meurer
the proposals will go through google-melange.com, and will be based on
https://github.com/sympy/sympy/wiki/GSoC-2012-Application-Template.
For now, if you are interested in applying, you should discuss your
ideas here on the mailing list.
Aaron Meurer
here as with the others, so I'll probably just go ahead and add it to
the ideas list.
Many times, people ask how they can tell what some functions are
doing. For example, they want to know step by step how
diff(x*sin(x**2), x) works, or integrate(x*sin(x**2), x). For the
former, the best you can do is to follow the code; for the latter, the
algorithm doesn't work at all like you would do it by hand, so there's
really no way.
The idea is to implement a way to do this. It would be along the
lines of WolframAlpha, where if you do certain operations (including
the above two), there is a button "Show steps," which shows everything
step by step.
The question is what would be a good interface for this? For the most
part, it would probably mean reimplementing the basic "by hand"
algorithms, so that you can determine exactly what steps are used.
What should the output look like, so that it is both readable and
usable (e.g., maybe some kind of annotated objects representing
operations that you can literally apply to an expression to do those
things).
Another question: for those operations where what SymPy does is pretty
close to what you'd do by hand (e.g., differentiation), what is a good
way to avoid code duplication and make things extensible?
Of course, we don't have to answer these questions before we can put
it on the ideas list: we can have the students interested in doing it
try to come up with the best ways, but I think it's good to discuss
ideas before hand.
Aaron Meurer
Joachim Durchholz
> The question is what would be a good interface for this?
Probably some tree transformation framework.
That way, the transformation steps exist as objects and can be
displayed, inspected, possibly varied etc.
And yes that would be sweet. In particular, if a formula gets
mistransformed, it would allow the user in question to pinpoint the
transformation that's in error, so people without a deep understanding
of the math behind some transformations could fix simple bugs.
(Right now, I wouldn't touch e.g. integral transformation. I have enough
math background to check the validity of some transformation, given a
pile of paper and a free weekend; I couldn't judge strategy. If the math
were separated from the Python mechanics, I could still work on the
mechanics if there's a bug in it.)
> For the most
> part, it would probably mean reimplementing the basic "by hand"
> algorithms, so that you can determine exactly what steps are used.
Definitely.
> What should the output look like, so that it is both readable and
> usable (e.g., maybe some kind of annotated objects representing
> operations that you can literally apply to an expression to do those
> things).
Have some way to specify transformation rules that work on an expression
tree.
It shouldn't be hard to represent these something like this:
a * (b + c) ---> a * b + a * c
We might even be able to use standard SymPy formula rendering; the only
new symbol would be the "transforms to" symbol, rendered as ---> in the
example above.
Rules should be associated with overall goals.
E.g. for boolean expressions, the goal could be conjunctive normal form,
disjunctive normal form, or minimum number of operators (the one you'd
set up a Karnaugh table for). You'd want different rules active
depending on the goal here.
Similar representational variations exist for sums of fractions.
Goals might work better if they can be restricted to a part of an
expression.
It might also be an idea to give each goal a weight; that way, users can
specify conflicting goals and let the transformation engine choose the
combination of goals that gives the best results. However, that's an
area for heuristics, so it's probably a good idea to review the
literature available on the subject.
Relevant key terms would be "term rewriting" and "tree transformation".
The nice thing is that it can be done incrementally: Have a basic tree
transformer in place, then gradually replace existing transformation
code with rule usage.
> Another question: for those operations where what SymPy does is pretty
> close to what you'd do by hand (e.g., differentiation), what is a good
> way to avoid code duplication and make things extensible?
I think the existing code would get replaced by rules.
You don't want to chase inconsistencies between transformation code and
rules.
Just my 2c.
Kanwar Singh
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sy...@googlegroups.com.
To unsubscribe from this group, send email to sympy+unsubscribe@googlegroups.com.
Aaron Meurer
> Am 15.02.2012 02:14, schrieb Aaron Meurer:
>
>> The question is what would be a good interface for this?
>
>
> Probably some tree transformation framework.
> That way, the transformation steps exist as objects and can be displayed,
> inspected, possibly varied etc.
>
> And yes that would be sweet. In particular, if a formula gets
> mistransformed, it would allow the user in question to pinpoint the
> transformation that's in error, so people without a deep understanding of
> the math behind some transformations could fix simple bugs.
> (Right now, I wouldn't touch e.g. integral transformation. I have enough
> math background to check the validity of some transformation, given a pile
> of paper and a free weekend; I couldn't judge strategy. If the math were
> separated from the Python mechanics, I could still work on the mechanics if
> there's a bug in it.)
Well, the more advanced algorithms would still be used when relevant.
In that case, only the simple cases implemented here would be
available. For example, if you enter a non-trivial integral into
WolframAlpha, or any integral requiring techniques beyond taking
anti-derivatives to compute (e.g., using residues), it does not show
the steps, because it uses the more advanced algorithms that do not
translate into steps.
I guess it would depend on how they compare in performance and power.
Aaron Meurer
>
> Just my 2c.
Aaron Meurer
with a note that there may be a potential issue with finding mentors.
If someone comes along and disagrees, feel free to remove them from
the wiki and further discuss them here.
Aaron Meurer
Aaron Meurer
as you see fit. I tried to put notes next to the tasks that might not
have mentors, so that students are aware of the fact.
Unrelated note: I also went through the whole page and tried to clean
it up. Tom, I completely removed the "idea" about integration with
Meijer G-functions, as it was basically what you did last year. Is
there enough work to fill another summer beyond what you did? If so,
can you add it to the list? Or maybe you are interested in doing it
yourself? There definitely is more work that can be done with respect
to definite integration, as as I was telling you on IRC a while back,
I can demonstrate a ton of integrals that it can't do, but which can
be computed easily using residue calculus (I can post these to an
issue or issues if you want). I also put a question next to the idea
about implementing an algorithm using residues, as I'm not sure if
that would really be required to get these all to work, or if the
Meijer G algorithm just needs to be extended more.
Aaron Meurer
Sameera Bandara
I'm Sameera Bandara, an undergraduate of Computer Science and
Engineering Department of University of Moratuwa. I have experience on
both Android and iPhone application development. I wish to participate
on GSOC 2012 and interested at the idea of Android application by
Aaron Meurer.
Regards,
Sameera Bandara
Roberto Colistete Jr.
As I have written in 12/02/2012, I can be a mentor with a project
restricted to making a SymPy GUI for Android using Python/SL4A. Using
webview or FullScreenUI (if it improves in the following months). Python
for iOS is not mature to develop GUI softwares.
Do I need to add anything specific to the SymPy GSoC ideas
(https://github.com/sympy/sympy/wiki/GSoC-2012-Ideas) ? Or the "Mobile
app for iOS and/or Andriod" idea description is enough ?
Anyway, it is very important to define the scope of this "mobile
front-end" for SymPy, because a SymPy front-end can be a very complex
software for many months of work (like the wxMaxima and Mathematica
front-ends). So, it is needed to discuss which capabilities a front-end
developed in 3-4 months could have ?
Roberto Colistete Jr.
Aaron Meurer
<roberto....@gmail.com> wrote:
> Hi,
>
> As I have written in 12/02/2012, I can be a mentor with a project
> restricted to making a SymPy GUI for Android using Python/SL4A. Using
> webview or FullScreenUI (if it improves in the following months). Python for
> iOS is not mature to develop GUI softwares.
>
> Do I need to add anything specific to the SymPy GSoC ideas
> (https://github.com/sympy/sympy/wiki/GSoC-2012-Ideas) ? Or the "Mobile app
> for iOS and/or Andriod" idea description is enough ?
Yes, please add any thoughts you have there. It will also be up to the
students to specify what they want to do in their proposals.
And if you are willing to mentor, please add your name to the bottom
of the page (if you only are willing to mentor specific projects, you
can add that after your name).
Aaron Meurer
>
> Anyway, it is very important to define the scope of this "mobile
> front-end" for SymPy, because a SymPy front-end can be a very complex
> software for many months of work (like the wxMaxima and Mathematica
> front-ends). So, it is needed to discuss which capabilities a front-end
> developed in 3-4 months could have ?
>
> Roberto Colistete Jr.
>
>
Roberto Colistete Jr.
On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr. <roberto....@gmail.com> wrote:Hi, As I have written in 12/02/2012, I can be a mentor with a project restricted to making a SymPy GUI for Android using Python/SL4A. Using webview or FullScreenUI (if it improves in the following months). Python for iOS is not mature to develop GUI softwares. Do I need to add anything specific to the SymPy GSoC ideas (https://github.com/sympy/sympy/wiki/GSoC-2012-Ideas) ? Or the "Mobile app for iOS and/or Andriod" idea description is enough ?Yes, please add any thoughts you have there. It will also be up to the students to specify what they want to do in their proposals.
About the "Mobile app for iOS and/or Andriod" idea, the text below is not needed for Android :
"If there are issues with running SymPy on the device
itself, we could make the app to just be a nice interface to SymPy
Live/Gamma. Perhaps it would be best to start doing this, and then
once you
have a nice interface, to work on running SymPy itself."
because SymPy runs very well using Python SL4A.
And if you are willing to mentor, please add your name to the bottom of the page (if you only are willing to mentor specific projects, you can add that after your name).
* Roberto Colistete Jr. (rcolistete), about "Mobile app for Android" using Python SL4A
Regards,
Roberto
Aaron Meurer
<roberto....@gmail.com> wrote:
> Em 04-03-2012 18:47, Aaron Meurer escreveu:
>
> On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr.
> <roberto....@gmail.com> wrote:
>
> Hi,
>
> As I have written in 12/02/2012, I can be a mentor with a project
> restricted to making a SymPy GUI for Android using Python/SL4A. Using
> webview or FullScreenUI (if it improves in the following months). Python for
> iOS is not mature to develop GUI softwares.
>
> Do I need to add anything specific to the SymPy GSoC ideas
> (https://github.com/sympy/sympy/wiki/GSoC-2012-Ideas) ? Or the "Mobile app
> for iOS and/or Andriod" idea description is enough ?
>
> Yes, please add any thoughts you have there. It will also be up to the
> students to specify what they want to do in their proposals.
>
>
> Hi Aaron,
>
> About the "Mobile app for iOS and/or Andriod" idea, the text below is
> not needed for Android :
>
> "If there are issues with running SymPy on the device itself, we could make
> the app to just be a nice interface to SymPy Live/Gamma. Perhaps it would be
> best to start doing this, and then once you have a nice interface, to work
> on running SymPy itself."
>
> because SymPy runs very well using Python SL4A.
Sure. That's why I put "if". But feel free to update the page to
make things more clear. You know more about the situation than I do.
Aaron Meurer
>
>
> And if you are willing to mentor, please add your name to the bottom
> of the page (if you only are willing to mentor specific projects, you
> can add that after your name).
>
>
> Ok, I've added :
>
> * Roberto Colistete Jr. (rcolistete), about "Mobile app for Android" using
> Python SL4A
>
> Regards,
>
> Roberto
>
Vipul Amler
On Tuesday, March 6, 2012 1:55:16 AM UTC+5:30, Aaron Meurer wrote:
On Sun, Mar 4, 2012 at 7:20 PM, Roberto Colistete Jr.
<roberto....@gmail.com> wrote:
> Em 04-03-2012 18:47, Aaron Meurer escreveu:
>
> On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr.
> <roberto....@gmail.com> wrote:
>
> Hi,
>
> As I have written in 12/02/2012, I can be a mentor with a project
> restricted to making a SymPy GUI for Android using Python/SL4A. Using
> webview or FullScreenUI (if it improves in the following months). Python for
> iOS is not mature to develop GUI softwares.
>
> Do I need to add anything specific to the SymPy GSoC ideas
> (https://github.com/sympy/sympy/wiki/GSoC-2012-Ideas) ? Or the "Mobile app
> for iOS and/or Andriod" idea description is enough ?
>
> Yes, please add any thoughts you have there. It will also be up to the
> students to specify what they want to do in their proposals.
>
>
> Hi Aaron,
>
> About the "Mobile app for iOS and/or Andriod" idea, the text below is
> not needed for Android :
>
> "If there are issues with running SymPy on the device itself, we could make
> the app to just be a nice interface to SymPy Live/Gamma. Perhaps it would be
> best to start doing this, and then once you have a nice interface, to work
> on running SymPy itself."
>
> because SymPy runs very well using Python SL4A.>Sure. That's why I put "if". But feel free to update the page to
>make things more clear. You know more about the situation than I do.>Aaron Meurer
>
>
> And if you are willing to mentor, please add your name to the bottom
> of the page (if you only are willing to mentor specific projects, you
> can add that after your name).
>
>
> Ok, I've added :
>
> * Roberto Colistete Jr. (rcolistete), about "Mobile app for Android" using
> Python SL4A
>
> Regards,
>
> Roberto
>
> --
> You received this message because you are subscribed to the Google Groups
> "sympy" group.
> To post to this group, send email to sy...@googlegroups.com.
> To unsubscribe from this group, send email to