Discussion:
Some ideas for GSoC
(too old to reply)
Aaron Meurer
2012-02-12 06:34:28 UTC
Permalink
Hi everyone.

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
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Tom Bachmann
2012-02-12 09:09:45 UTC
Permalink
Hi,
Post by Aaron Meurer
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...)
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Roberto Colistete Jr.
2012-02-12 13:46:17 UTC
Permalink
Post by Aaron Meurer
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
<http://talk.maemo.org/showthread.php?t=75658>, Derivative
<http://talk.maemo.org/showthread.php?p=1109972> and Limit
<http://talk.maemo.org/showthread.php?p=1112582> 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
<http://talk.maemo.org/showthread.php?t=78568> 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 sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-02-12 20:10:08 UTC
Permalink
On Sun, Feb 12, 2012 at 6:46 AM, Roberto Colistete Jr.
Post by Aaron Meurer
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,
- 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
http://code.google.com/p/android-scripting/wiki/ApiReference
http://code.google.com/p/android-scripting/wiki/UsingWebView
http://www.robertocolistete.net/Python/Android/
http://android-scripting.blogspot.com/2010/11/sms-merger-reviewed-with.html
* FullScreenUI experimental, it needs sl4a_r5x (beta), but it is not
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;
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
Post by 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
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 unsubscribe from this group, send email to
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+***@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
beast11
2012-02-14 11:27:11 UTC
Permalink
Post by Aaron Meurer
On Sun, Feb 12, 2012 at 6:46 AM, Roberto Colistete Jr.
Post by Aaron Meurer
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,
- 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
http://code.google.com/p/android-scripting/wiki/ApiReference
http://code.google.com/p/android-scripting/wiki/UsingWebView
http://www.robertocolistete.net/Python/Android/
http://android-scripting.blogspot.com/2010/11/sms-merger-reviewed-wit...
* FullScreenUI experimental, it needs sl4a_r5x (beta), but it is not
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;
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
A Project related to improvement on SymPy is favorable as it is still
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?
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+***@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-02-14 17:41:19 UTC
Permalink
It's still early to do the proposals themselves. If we are accepted,
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
Post by beast11
A Project related to improvement on SymPy is favorable as it is still
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?
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-02-15 01:14:03 UTC
Permalink
Here's another idea for GSoC. I don't think there's as much doubt
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
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Joachim Durchholz
2012-02-15 18:20:01 UTC
Permalink
Post by 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.)
Post by Aaron Meurer
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.
Post by Aaron Meurer
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.
Post by Aaron Meurer
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.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Kanwar Singh
2012-02-15 18:49:22 UTC
Permalink
Such kind of project can be helpful in making students understand
programming skills and giving them knowledge for basic mathematical problems
It can be also helpful for the Professors for teaching.
Post by 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.)
Post by Aaron Meurer
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
Post by Aaron Meurer
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.
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
Post by Aaron Meurer
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.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
For more options, visit this group at http://groups.google.com/**
group/sympy?hl=en <http://groups.google.com/group/sympy?hl=en>.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-02-15 20:13:02 UTC
Permalink
Post by Joachim Durchholz
Post by 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.
Post by Joachim Durchholz
Post by Aaron Meurer
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.
Post by Aaron Meurer
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.
 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.
Post by Aaron Meurer
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.
I guess it would depend on how they compare in performance and power.

Aaron Meurer
Post by Joachim Durchholz
Just my 2c.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To unsubscribe from this group, send email to
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+***@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-02-16 17:39:07 UTC
Permalink
Well, having not heard anything else, I think I'll just add these,
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
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-02-18 06:09:35 UTC
Permalink
I added all these ideas. Please feel free as always to edit the page
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
Post by Aaron Meurer
Well, having not heard anything else, I think I'll just add these,
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
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Sameera Bandara
2012-03-03 18:33:45 UTC
Permalink
Hi all,

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
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Roberto Colistete Jr.
2012-03-04 20:47:04 UTC
Permalink
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 ?

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.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-03-04 21:47:28 UTC
Permalink
On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr.
   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.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To unsubscribe from this group, send email to
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+***@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Roberto Colistete Jr.
2012-03-05 02:20:24 UTC
Permalink
Post by Aaron Meurer
On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr.
Post by Roberto Colistete Jr.
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.

**
Post by 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 sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Aaron Meurer
2012-03-05 20:25:16 UTC
Permalink
On Sun, Mar 4, 2012 at 7:20 PM, Roberto Colistete Jr.
Post by Aaron Meurer
On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr.
   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
"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
Post by 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).
* 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 unsubscribe from this group, send email to
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+***@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Vipul Amler
2012-03-06 03:39:42 UTC
Permalink
Post by Aaron Meurer
On Sun, Mar 4, 2012 at 7:20 PM, Roberto Colistete Jr.
Post by Aaron Meurer
On Sun, Mar 4, 2012 at 1:47 PM, Roberto Colistete Jr.
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
Post by Aaron Meurer
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
Post by Aaron Meurer
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
"If there are issues with running SymPy on the device itself, we could
make
Post by Aaron Meurer
the app to just be a nice interface to SymPy Live/Gamma. Perhaps it
would be
Post by Aaron Meurer
best to start doing this, and then once you have a nice interface, to
work
Post by Aaron Meurer
on running SymPy itself."
Hi
I am Vipul, student and an Android Developer.
I am interested in the Android App for SymPy, and would like to be a part
of it.
So how could I approach this?
Post by Aaron Meurer
Post by Aaron Meurer
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).
* Roberto Colistete Jr. (rcolistete), about "Mobile app for Android"
using
Post by Aaron Meurer
Python SL4A
Regards,
Roberto
--
You received this message because you are subscribed to the Google Groups
"sympy" group.
To unsubscribe from this group, send email to
For more options, visit this group at
http://groups.google.com/group/sympy?hl=en.
--
You received this message because you are subscribed to the Google Groups "sympy" group.
To view this discussion on the web visit https://groups.google.com/d/msg/sympy/-/sjSTySG-B_wJ.
To post to this group, send email to sympy-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
To unsubscribe from this group, send email to sympy+unsubscribe-/JYPxA39Uh5TLH3MbocFF+G/***@public.gmane.org
For more options, visit this group at http://groups.google.com/group/sympy?hl=en.
Continue reading on narkive:
Loading...