On Thu, Mar 13, 2014 at 11:37 AM, Jason Moore <moorepa...@gmail.com> wrote:
> Some comments:
>
> - In general, you can only use the Jacobian if you have an unconstrained
> system and the operating point is zero. If the operating point is not zero,
> then you need the full linear portion of the Taylor series about some point
> other than zero. Also, for some subset of constrained systems and particular
> equilibria points the chain rule evaluates to the same thing as the Taylor
> series (this is the case for the upright equilibrium of the Whipple bicycle
> model). Jacobians are a matrix operation.
>
> - If things are complicated enough, we typically use a class to manage data
> and then may write a functional wrapper around the class for a specific use
> case. Should your linearization code be structured as classes instead of a
> function with subroutines? This may warrant a "Linearizer" class or
> something if it will be easier to handle all of the data needed. I'd think
> some about that, maybe speak on pros and cons of each way.
>
> - The PDE stuff isn't explained. I'd either remove it or expand. The PDE's
> will be a function of space in 3 dimensions and time for flexible systems or
> electromagnetic systems. We don't have those things working yet, so maybe
> this is thinking too far ahead. But if you designed your code to work with
> functions of space and time, it would work for whatever we eventually have
> when the PDE producing methods work.
>
> - Maybe describe the mathematical form of the type of inputs to the
> linearize function. In general is it computationally inefficient to
> symbolically form xdot = f, we typically work with M * xdot = F as M^-1 * F
> should be computed numerically.
>
> - I like the option to both output M, C, K and Q and A, B.
>
> - Another thing we've found useful, is to linearize about an arbitrary
> equilibrium point, then generate numerical code from that. Then you have the
> equations that produce the linear system for any given equilibria. We should
> include some code generation functionality in the linearize class or update
> the current sympy code gen stuff to handle matrices easily.
>
> - The early linearization has potential to make simplified linear forms of
> the linear EoMs. I'm not sure how this generalizes to all methods (Lagrange,
> Kane, Hamilton, etc), but Kane's book has a section detailing when exactly
> you can start to linearize the problem.
>
> - This linearization stuff may or may not be enough to fill the summer. You
> seem very familiar with Python and you know dynamics, so you may be able to
> make quick headway. If you want to add optional items related to speeding up
> the symbolic derivations or adding another method (NewtonEulerMethod,
> HamiltonMethod, etc), then that may be a good idea.
>
> - Some research into efficient methods of symbolic linearization could be
> done. You may be able to use the common structure and common terms in
> linearizing m-body systems to do some simplification along the way more
> efficiently.
>
> - What happens when the equations of motion have funny things in them like
> Piecewise functions. Some non-linearities may be trickier to deal with and
> we should support them. Think about a bouncing ball simulation. How do we
> support those from the symbolic end? I suspect that an inverted pendulum
> with hard impact constraints at max angles could be tricky. In general,
> small angles would just remove that non-linearity, but we want to make sure
> these things are handled.
>
> - Be sure to include plenty of time for creating documentation, tutorials,
> and examples. This always gets neglected! I wouldn't just wait till the end
> to do this, as it rarely gets done. Do it at each step of the process.
In a similar vein:
- Expect to submit a pull request as often as possible. Whenever you
have workable code, you should submit a PR. What you want to avoid is
one mega-pull request at the end of the summer that is too big for
anyone to review.
- Each PR should come with tests and documentation. It's much easier
to test and document as you go than to do it at the end. Plus, if you
do this, you will find yourself avoiding bad design much sooner than
you otherwise would.
Aaron Meurer
>
>
> Jason
> moorepants.info
> +01 530-601-9791
>
>
> On Wed, Mar 12, 2014 at 3:06 AM, James Crist <crist...@umn.edu> wrote:
>>
>> All,
>>
>> A draft of my application has been posted here. It could definitely use
>> some critiquing and editing.
>>
>> A couple things I wasn't sure of:
>>
>> 1.) The interface was based purely on my thoughts, and may not be desired
>> by everyone
>>
>> 2.) Is there anything in the scope of this project that I missed? Is there
>> anything I included that is not in scope?
>>
>> 3.) Mathematical background? Not enough? Too much? I'm used to Mathjax in
>> my markdown, which is why there are $ littered everywhere. I'll clean those
>> out later. Not sure if I can even submit math to melange.
>>
>> 4.) My background? I included it because sympy and pydy had it in their
>> application template. However, I noticed that neither Sachin nor Tarun
>> included it. Not sure how much is really necessary, as I assume most things
>> should be project specific.
>>
>>
>> I will be leaving on Friday, and will (probably) not have access to
>> internet until the following saturday, so I'm trying to get this done in the
>> next few days. So comments would be highly appreciated.
>>
>> Thanks!
>>
>> -Jim
>>
>>
>>
>>
>> On Tuesday, March 11, 2014 10:53:21 PM UTC-5, James Crist wrote:
>>>
>>> Jason,
>>>
>>> Thanks for the clarification. With the added info, I can see how to make
>>> this into a full summer project. I'm working on finishing my proposal, and I
>>> should get a first draft up hopefully tonight. Here's my thoughts on the
>>> basic functionality:
>>>
>>> 1.) A function ("linearize", or something like it). Would work much like
>>> solve does, having multiple sub methods, and paths for different system
>>> types. Should be able to handle normal unconstrained linearization (just a
>>> jacobian), as well as constraints, and possibly pdes. Ideally this could
>>> linearize systems of equations generated in places other than mechanics as
>>> well. Call signature would be something along the lines of:
>>>
>>> linearize(exression, *args, **kwargs)
>>>
>>> This would allow for different types (just a state vector, state and
>>> input, etc...), as well as hints if facts about the system are known (nature
>>> of constraints, etc). The hints should not be necessary, but may reduce
>>> computation time.
>>>
>>> 2.) Methods added to lagrange, and a refactor or kane, that call
>>> linearize with hints (the classes should have some knowledge of the system,
>>> which would help)
>>>
>>> 3.) A "linearized_eom" method in kane and lagrange, that starts with
>>> linearization from the get-go. Should make deriving the eom faster, and
>>> makes sense if you know you're going to want to linearize them later on.
>>>
>>> I envision "linearize" returning the M, K, C, and Q matrices for M*ddq +
>>> K*dq + C*q = Q. Could also add a kwarg for A and B matrices, if that
>>> standard form is more desirable. Those can easily be derived from M, K, C,
>>> and Q though.
>>>
>>> Thoughts?
>>>
>>> On Tuesday, March 11, 2014 10:31:30 PM UTC-5, moorepants wrote:
>>>>
>>>> Another note on linearization. It is possible to linearize a system
>>>> partially through the symbolic derivation. You can linearize before the
>>>> formation of the equations of motion and get the linear system. It could be
>>>> nice to include that in the Methods classes so that if you know you want a
>>>> linear model you can linearize earlier on in the process.
>>>>
>>>>
>>>> Jason
>>>> moorepants.info
>>>> +01 530-601-9791
>>>>
>>>>
>>>> On Tue, Mar 11, 2014 at 3:45 PM, Jason Moore <moore...@gmail.com> wrote:
>>>>>
>>>>> Jim,
>>>>>
>>>>> Getting a really nice clean and robust linearizion class for multibody
>>>>> systems can potentially fill the the summer. As Aaron mentions, everyone
>>>>> overestimates what they can get done. Multibody systems which are simply a
>>>>> function of time (not space) have a specific form, essentially Mxdot = F.
>>>>> The paper shows how you can carefully linearize systems with complex
>>>>> constraints. The implementation of that would likely be straightforward,
>>>>> but
>>>>> we would want a class that can accept multiple "forms" of the EoM and then
>>>>> linearize the equations correctly and efficiently. You'd be developing
>>>>> example problems with no constraints and ones with complex constraints and
>>>>> using them as tests to ensure the linear equations are correct. The
>>>>> efficiency is important too. For the differentiation steps you can look
>>>>> into
>>>>> possible ways to improve the speed by utilizing the common form of the
>>>>> EoM's. There maybe some ways to speed up the differentiation from an
>>>>> algorithmic standpoint. Also this can be sped up by using the CSymPy core.
>>>>> We'd really like to get that working. Also from an academic standpoint,
>>>>> the
>>>>> linear EoMs should always be shorter and simpler than the nonlinear form,
>>>>> but because the algorithms for simplification are not great, we could
>>>>> spend
>>>>> time trying to ensure that our linearizer not only gets the correct
>>>>> equations but also simplifies them to a readable form. For many super
>>>>> complex nonlinear EoMs, there is often a human readable form of the linear
>>>>> EoMs about specific operating points. For example, if our linearizer could
>>>>> linearize the bicycle EoMs to it's simplest form, which can be done by
>>>>> deriving the linear model from the get go, then we'd have something more
>>>>> special than other CAS based multibody dynamic engines. So, simplification
>>>>> is a big challenge. Another thing would be to think about how this would
>>>>> play with a system that is a function of time and space (linearizing PDEs
>>>>> for flexible systems and the electromagnetic systems).
>>>>>
>>>>> So the linearization project can be big, especially if you want to make
>>>>> it better than what currently exists on the market.
>>>>>
>>>>> But speeding up the EoM derivations and the linearizations is important
>>>>> too. I think you will touch on these whatever you decide to do. We all
>>>>> want
>>>>> the code to be fast and there are lots of places to improve this.
>>>>>
>>>>>
>>>>> Jason
>>>>> moorepants.info
>>>>> +01 530-601-9791
>>>>>
>>>>>
>>>>> On Mon, Mar 10, 2014 at 8:57 PM, Aaron Meurer <asme...@gmail.com>
>>>>> wrote:
>>>>>>
>>>>>> I don't know enough about the details to comment on this specific
>>>>>> project, but you should note that just about everyone underestimates
>>>>>> how long a given project will take. Whether they don't account for bug
>>>>>> fixing, debugging, documenting, or something else I don't know.
>>>>>>
>>>>>> But having a little more to do at the end of the summer is not all bad
>>>>>> because that encourages you to stick around to finish it.
>>>>>>
>>>>>> Aaron Meurer
>>>>>>
>>>>>> On Mon, Mar 10, 2014 at 4:11 PM, James Crist <cris...@umn.edu> wrote:
>>>>>> > After having read through the paper Jason posted, I'm not sure if
>>>>>> > there's
>>>>>> > enough work to be done here over the summer. KanesMethod already has
>>>>>> > a
>>>>>> > linearization method implemented. If I understand correctly, the
>>>>>> > intent is
>>>>>> > that this method is pulled out and put into a class of it's own that
>>>>>> > will
>>>>>> > handle general linearization of equations of motion? Methods for
>>>>>> > handling
>>>>>> > lagrange equations would need to be added, and probably a general
>>>>>> > linearization routine for non-constrained systems (I think this
>>>>>> > would just
>>>>>> > do the jacobian). I'm just not sure how to break this up into
>>>>>> > meaningful
>>>>>> > steps to timeline for the proposal. If someone could explain the
>>>>>> > intentions
>>>>>> > here, that would be helpful.
>>>>>> >
>>>>>> > On that note, some of the other projects also look interesting. I
>>>>>> > took a
>>>>>> > look through simbody, and the functionality provided by their
>>>>>> > library could
>>>>>> > be very useful in association with pydy. Also, as can be seen in my
>>>>>> > lagranges method example posted yesterday, solving the equations of
>>>>>> > motion
>>>>>> > of a complicated system takes a considerable amount of time. Without
>>>>>> > subbing
>>>>>> > in constants beforehand, I let the calculations run for 45 min
>>>>>> > before I gave
>>>>>> > up and interrupted the operation. So improvements to equations of
>>>>>> > motion
>>>>>> > generation could be valuable as well.
>>>>>> >
>>>>>> > Basically, I'm looking for a project of substantial size. If the
>>>>>> > linearization project is more in depth than I'm thinking, I'd be
>>>>>> > fine
>>>>>> > submitting for that. Otherwise the Simbody wrapper or the
>>>>>> > improvements to
>>>>>> > E.O.M. generation efficiency sound more appealing. Could someone
>>>>>> > give me a
>>>>>> > brief overview of these projects and the intentions behind them?
>>>>>> >
>>>>>> > - Jim
>>>>>> >
>>>>>> >
>>>>>> >
>>>>>> >
>>>>>> > On Monday, March 3, 2014 4:30:02 PM UTC-6, moorepants wrote:
>>>>>> >>
>>>>>> >> Awesome, I'm looking forward to see what you have to show us both
>>>>>> >> previous
>>>>>> >> work and a proposal.
>>>>>> >>
>>>>>> >>
>>>>>> >> Jason
>>>>>> >> moorepants.info
>>>>>> >> +01 530-601-9791
>>>>>> >>
>>>>>> >>
>>>>>> >> On Mon, Mar 3, 2014 at 4:56 PM, James Crist <cris...@umn.edu>
>>>>>> >> wrote:
>>>>>> >>>
>>>>>> >>> Thanks for the info. I've actually already submitted a patch to
>>>>>> >>> the
>>>>>> >>> lambdify function, as you saw. When/if that gets merged I'll fix
>>>>>> >>> the related
>>>>>> >>> issue in the pydy codegen repo. I'll try to whip some of my past
>>>>>> >>> work into a
>>>>>> >>> nicely presented ipython notebook, and send a pull request to put
>>>>>> >>> it in the
>>>>>> >>> examples. Probably related to a robotic platform and the use of
>>>>>> >>> the
>>>>>> >>> lagrangian method. I'll also start a wiki page for my proposal.
>>>>>> >>> This is a
>>>>>> >>> busy week here, so most likely none of this will happen until
>>>>>> >>> around
>>>>>> >>> Thursday-Friday or so.
>>>>>> >>>
>>>>>> >>> Thanks,
>>>>>> >>> -Jim
>>>>>> >>>
>>>>>> >>>
>>>>>> >>> On Sunday, March 2, 2014 12:12:42 PM UTC-6, moorepants wrote:
>>>>>> >>>>
>>>>>> >>>> Some answers:
>>>>>> >>>>
>>>>>> >>>> - What can I do to get involved beforehand/even if I don't get
>>>>>> >>>> accepted?
>>>>>> >>>> As I said, I make heavy use of sympy mechanics and the whole
>>>>>> >>>> python science
>>>>>> >>>> stack in my research, and would love to contribute back.
>>>>>> >>>>
>>>>>> >>>> We have open issues in SymPy and the PyDy projects on Github.
>>>>>> >>>> Browse
>>>>>> >>>> through them and see if you'd like to try fixing one. If you want
>>>>>> >>>> to apply
>>>>>> >>>> to GSoC through SymPy then you will have to submit a pull request
>>>>>> >>>> there.
>>>>>> >>>> Best to get started on that ASAP.
>>>>>> >>>>
>>>>>> >>>> We also love to have examples in the pydy_examples repo. If you
>>>>>> >>>> can
>>>>>> >>>> contribute soem things you already created that would be great.
>>>>>> >>>> We will soon
>>>>>> >>>> be making an example gallery like matplotlib.org has but for PyDy
>>>>>> >>>> problems
>>>>>> >>>> all with nice 3D visualizations embedded in the website. If you
>>>>>> >>>> want to
>>>>>> >>>> initiate that, that is also an easy way to get started.
>>>>>> >>>>
>>>>>> >>>> - What would the next step be in applying? I see your
>>>>>> >>>> "umbrellaed" under
>>>>>> >>>> both Python and Sympy. I assume since sympy is closer I'd need to
>>>>>> >>>> talk to
>>>>>> >>>> them?
>>>>>> >>>>
>>>>>> >>>> Key things: 1) Start on a patch in SymPy (browse through issues
>>>>>> >>>> for
>>>>>> >>>> ideas), or ask here. 2) Browse the ideas page and start asking
>>>>>> >>>> questions
>>>>>> >>>> about it here. 3) Start developing a proposal here:
>>>>>> >>>> https://github.com/pydy/pydy/wiki and ask for out feedback. The
>>>>>> >>>> sooner the
>>>>>> >>>> better.
>>>>>> >>>>
>>>>>> >>>>
>>>>>> >>>> Jason
>>>>>> >>>> moorepants.info
>>>>>> >>>> +01 530-601-9791
>>>>>> >>>>
>>>>>> >>>>
>>>>>> >>>> On Sun, Mar 2, 2014 at 11:44 AM, James Crist <cris...@umn.edu>
>>>>>> >>>> wrote:
>>>>>> >>>>>
>>>>>> >>>>> @Gilbert:
>>>>>> >>>>>
>>>>>> >>>>> My research is on estimation and control of electromechanical
>>>>>> >>>>> systems.
>>>>>> >>>>> The basic workflow I use is:
>>>>>> >>>>> 1.) Derive the equations of motion in sympy.
>>>>>> >>>>> 2.) Lamdify them into numpy expressions, for faster simulation
>>>>>> >>>>> 3.) System id using an in-shop python tool for data collection
>>>>>> >>>>> and
>>>>>> >>>>> analysis (cleaning this up to put on github soon)
>>>>>> >>>>> 4.) Develop a controller using python-control
>>>>>> >>>>>
>>>>>> >>>>> I haven't used any of the pydy specific toolset, but have used
>>>>>> >>>>> the
>>>>>> >>>>> Lagrange's method code in classical mechanics to derive
>>>>>> >>>>> equations of motion
>>>>>> >>>>> for a robot for modeling, analysis, and design optimization. I
>>>>>> >>>>> was never
>>>>>> >>>>> taught kane's method (although it looks super useful), so I
>>>>>> >>>>> can't comment on
>>>>>> >>>>> the code for that. The lagrange's method code is slick though.
>>>>>> >>>>>
>>>>>> >>>>> @Aaron:
>>>>>> >>>>>
>>>>>> >>>>> Thanks for the heads up, I'll see what I can contribute.
>>>>>> >>>>>
>>>>>> >>>>> @Jason:
>>>>>> >>>>>
>>>>>> >>>>> Thanks for the paper, I'll give it a read later today.
>>>>>> >>>>>
>>>>>> >>>>> -Jim
>>>>>> >>>>>
>>>>>> >>>>>
>>>>>> >>>>> On Saturday, March 1, 2014 5:50:47 PM UTC-6, moorepants wrote:
>>>>>> >>>>>>
>>>>>> >>>>>> James,
>>>>>> >>>>>>
>>>>>> >>>>>> Here is the paper. I'll respond more in a bit.
>>>>>> >>>>>>
>>>>>> >>>>>>
>>>>>> >>>>>> Jason
>>>>>> >>>>>> moorepants.info
>>>>>> >>>>>> +01 530-601-9791
>>>>>> >>>>>>
>>>>>> >>>>>>
>>>>>> >>>>>> On Fri, Feb 28, 2014 at 4:55 PM, Aaron Meurer
>>>>>> >>>>>> <asme...@gmail.com>
>>>>>> >>>>>> wrote:
>>>>>> >>>>>>>
>>>>>> >>>>>>> "Umbrella'd" means that the PyDy GSoC proposals will be
>>>>>> >>>>>>> accepted
>>>>>> >>>>>>> under
>>>>>> >>>>>>> one of those two orgs, since PyDy wan't accepted as its own
>>>>>> >>>>>>> org. What
>>>>>> >>>>>>> it means for you is that you will need to satisfy the
>>>>>> >>>>>>> application
>>>>>> >>>>>>> requirements of whichever org you apply to. I don't know if
>>>>>> >>>>>>> PSF has
>>>>>> >>>>>>> any requirements, but for SymPy, you need to have a patch
>>>>>> >>>>>>> merged. See
>>>>>> >>>>>>>
>>>>>> >>>>>>> https://github.com/sympy/sympy/wiki/gsoc-2014-application-template.
>>>>>> >>>>>>> Since you've already been using SymPy, a good option for this
>>>>>> >>>>>>> is to
>>>>>> >>>>>>> try to fix some bug that you've come across, or implement some
>>>>>> >>>>>>> missing
>>>>>> >>>>>>> feature that you would have found nice.
>>>>>> >>>>>>>
>>>>>> >>>>>>> Aaron Meurer
>>>>>> >>>>>>>
>>>>>> >>>>>>> On Fri, Feb 28, 2014 at 1:42 PM, Gilbert Gede
>>>>>> >>>>>>> <gilbe...@gmail.com>
>>>>>> >>>>>>> wrote:
>>>>>> >>>>>>> > Hi James,
>>>>>> >>>>>>> > Glad to see someone else is using our tools! Do you mind
>>>>>> >>>>>>> > sharing
>>>>>> >>>>>>> > some of
>>>>>> >>>>>>> > what you've used it for? Seeing how others are using the
>>>>>> >>>>>>> > software
>>>>>> >>>>>>> > will help
>>>>>> >>>>>>> > us to improve it.
>>>>>> >>>>>>> > I'm not going to be very involved in GSoC this year, but
>>>>>> >>>>>>> > Jason will
>>>>>> >>>>>>> > be
>>>>>> >>>>>>> > (although he's preparing for a conference that is in 4
>>>>>> >>>>>>> > days).
>>>>>> >>>>>>> > You'll want to
>>>>>> >>>>>>> > follow up with him what projects would be a good fit for
>>>>>> >>>>>>> > you.
>>>>>> >>>>>>> > Regarding the paper, it is still under review... so building
>>>>>> >>>>>>> > the
>>>>>> >>>>>>> > tex file is
>>>>>> >>>>>>> > your best option right now.
>>>>>> >>>>>>> >
>>>>>> >>>>>>> > -Gilbert
>>>>>> >>>>>>> >
>>>>>> >>>>>>> >
>>>>>> >>>>>>> >
>>>>>> >>>>>>> > On Thu, Feb 27, 2014 at 9:34 PM, James Crist
>>>>>> >>>>>>> > <cris...@umn.edu>
>>>>>> >>>>>>> > wrote:
>>>>>> >>>>>>> >>
>>>>>> >>>>>>> >> Hello!
>>>>>> >>>>>>> >>
>>>>>> >>>>>>> >> I'm interested in your project, having used the sympy
>>>>>> >>>>>>> >> mechanics,
>>>>>> >>>>>>> >> numpy/scipy, python-control stack for most of my homework
>>>>>> >>>>>>> >> and
>>>>>> >>>>>>> >> research. I'm
>>>>>> >>>>>>> >> a Mechanical Engineering Master's student focusing on
>>>>>> >>>>>>> >> system
>>>>>> >>>>>>> >> dynamics and
>>>>>> >>>>>>> >> controls at the University of Minnesota.
>>>>>> >>>>>>> >>
>>>>>> >>>>>>> >> Specifically, I'm interested in the "Linearization"
>>>>>> >>>>>>> >> project, or
>>>>>> >>>>>>> >> possibly
>>>>>> >>>>>>> >> in the "Efficient Code Generation". I've worked extensively
>>>>>> >>>>>>> >> with
>>>>>> >>>>>>> >> Python (4+
>>>>>> >>>>>>> >> years experience), and have some experience in other
>>>>>> >>>>>>> >> languages as
>>>>>> >>>>>>> >> well
>>>>>> >>>>>>> >> (Julia, C, Matlab, and a little bit of Fortran).
>>>>>> >>>>>>> >> Unfortunately, I
>>>>>> >>>>>>> >> just got
>>>>>> >>>>>>> >> on Github, so I don't have much to show for my work
>>>>>> >>>>>>> >> (there's no
>>>>>> >>>>>>> >> python code
>>>>>> >>>>>>> >> up there for starters): https://github.com/jcrist.
>>>>>> >>>>>>> >>
>>>>>> >>>>>>> >> Questions:
>>>>>> >>>>>>> >> - Is there a way I can find the paper "A linearization
>>>>>> >>>>>>> >> procedure
>>>>>> >>>>>>> >> for
>>>>>> >>>>>>> >> constrained multibody systems"? University database didn't
>>>>>> >>>>>>> >> turn
>>>>>> >>>>>>> >> anything up,
>>>>>> >>>>>>> >> but googling brought up the tex file. I suppose I could
>>>>>> >>>>>>> >> read that.
>>>>>> >>>>>>> >> - What can I do to get involved beforehand/even if I don't
>>>>>> >>>>>>> >> get
>>>>>> >>>>>>> >> accepted?
>>>>>> >>>>>>> >> As I said, I make heavy use of sympy mechanics and the
>>>>>> >>>>>>> >> whole
>>>>>> >>>>>>> >> python science
>>>>>> >>>>>>> >> stack in my research, and would love to contribute back.
>>>>>> >>>>>>> >> - What would the next step be in applying? I see your
>>>>>> >>>>>>> >> "umbrellaed"
>>>>>> >>>>>>> >> under
>>>>>> >>>>>>> >> both Python and Sympy. I assume since sympy is closer I'd
>>>>>> >>>>>>> >> need to
>>>>>> >>>>>>> >> talk to
>>>>>> >>>>>>> >> them?
>>>>>> >>>>>>> >>
>>>>>> >>>>>>> >> Thanks,
>>>>>> >>>>>>> >> - Jim
>>>>>> >>>>>>> >>
>>>>>> >>>>>>> >> --
>>>>>> >>>>>>> >> You received this message because you are subscribed to the
>>>>>> >>>>>>> >> Google
>>>>>> >>>>>>> >> Groups
>>>>>> >>>>>>> >> "PyDy" group.
>>>>>> >>>>>>> >> To unsubscribe from this group and stop receiving emails
>>>>>> >>>>>>> >> from it,
>>>>>> >>>>>>> >> send an
>>>>>> >>>>>>> >> email to pydy+uns...@googlegroups.com.
>>>>>> >>>>>>> >> To post to this group, send email to
>>>>>> >>>>>>> >> py...@googlegroups.com.
>>>>>> >>>>>>>
>>>>>> >>>>>>> >> Visit this group at http://groups.google.com/group/pydy.
>>>>>> >>>>>>> >> For more options, visit
>>>>>> >>>>>>> >> https://groups.google.com/groups/opt_out.
>>>>>> >>>>>>> >
>>>>>> >>>>>>> >
>>>>>> >>>>>>> > --
>>>>>> >>>>>>> > You received this message because you are subscribed to the
>>>>>> >>>>>>> > Google
>>>>>> >>>>>>> > Groups
>>>>>> >>>>>>> > "PyDy" group.
>>>>>> >>>>>>> > To unsubscribe from this group and stop receiving emails
>>>>>> >>>>>>> > from it,
>>>>>> >>>>>>> > send an
>>>>>> >>>>>>> > email to pydy+uns...@googlegroups.com.
>>>>>> >>>>>>> > To post to this group, send email to py...@googlegroups.com.
>>>>>> >>>>>>>
>>>>>> >>>>>>> > Visit this group at http://groups.google.com/group/pydy.
>>>>>> >>>>>>> > For more options, visit
>>>>>> >>>>>>> > https://groups.google.com/groups/opt_out.
>>>>>> >>>>>>>
>>>>>> >>>>>>> --
>>>>>> >>>>>>> You received this message because you are subscribed to the
>>>>>> >>>>>>> Google
>>>>>> >>>>>>> Groups "PyDy" group.
>>>>>> >>>>>>> To unsubscribe from this group and stop receiving emails from
>>>>>> >>>>>>> it,
>>>>>> >>>>>>> send an email to pydy+uns...@googlegroups.com.
>>>>>> >>>>>>> To post to this group, send email to py...@googlegroups.com.
>>>>>> >>>>>>>
>>>>>> >>>>>>> Visit this group at http://groups.google.com/group/pydy.
>>>>>> >>>>>>> For more options, visit
>>>>>> >>>>>>> https://groups.google.com/groups/opt_out.
>>>>>> >>>>>>
>>>>>> >>>>>>
>>>>>> >>>>> --
>>>>>> >>>>> You received this message because you are subscribed to the
>>>>>> >>>>> Google
>>>>>> >>>>> Groups "PyDy" group.
>>>>>> >>>>> To unsubscribe from this group and stop receiving emails from
>>>>>> >>>>> it, send
>>>>>> >>>>> an email to pydy+uns...@googlegroups.com.
>>>>>> >>>>> To post to this group, send email to py...@googlegroups.com.
>>>>>> >>>>> Visit this group at http://groups.google.com/group/pydy.
>>>>>> >>>>> For more options, visit
>>>>>> >>>>> https://groups.google.com/groups/opt_out.
>>>>>> >>>>
>>>>>> >>>>
>>>>>> >>> --
>>>>>> >>> You received this message because you are subscribed to the Google
>>>>>> >>> Groups
>>>>>> >>> "PyDy" group.
>>>>>> >>> To unsubscribe from this group and stop receiving emails from it,
>>>>>> >>> send an
>>>>>> >>> email to pydy+uns...@googlegroups.com.
>>>>>> >>> To post to this group, send email to py...@googlegroups.com.
>>>>>> >>> Visit this group at http://groups.google.com/group/pydy.
>>>>>> >>> For more options, visit https://groups.google.com/groups/opt_out.
>>>>>> >>
>>>>>> >>
>>>>>> > --
>>>>>> > You received this message because you are subscribed to the Google
>>>>>> > Groups
>>>>>> > "PyDy" group.
>>>>>> > To unsubscribe from this group and stop receiving emails from it,
>>>>>> > send an
>>>>>> > email to pydy+uns...@googlegroups.com.
>>>>>> > To post to this group, send email to py...@googlegroups.com.
>>>>>> > Visit this group at http://groups.google.com/group/pydy.
>>>>>> > For more options, visit https://groups.google.com/d/optout.
>>>>>>
>>>>>> --
>>>>>> You received this message because you are subscribed to the Google
>>>>>> Groups "PyDy" group.
>>>>>> To unsubscribe from this group and stop receiving emails from it, send
>>>>>> an email to pydy+uns...@googlegroups.com.
>>>>>> To post to this group, send email to py...@googlegroups.com.
>>>>>> Visit this group at http://groups.google.com/group/pydy.
>>>>>> For more options, visit https://groups.google.com/d/optout.
>>>>>
>>>>>
>>>>
>> --
>> You received this message because you are subscribed to the Google Groups
>> "PyDy" group.
>> To unsubscribe from this group and stop receiving emails from it, send an
>> email to pydy+unsubscr...@googlegroups.com.
>> To post to this group, send email to p...@googlegroups.com.
>> Visit this group at http://groups.google.com/group/pydy.
>> For more options, visit https://groups.google.com/d/optout.
>
>
> --
> You received this message because you are subscribed to the Google Groups
> "PyDy" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to pydy+unsubscr...@googlegroups.com.
> To post to this group, send email to p...@googlegroups.com.
> Visit this group at http://groups.google.com/group/pydy.
> For more options, visit https://groups.google.com/d/optout.
--
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 sympy+unsubscr...@googlegroups.com.
To post to this group, send email to sympy@googlegroups.com.
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/CAKgW%3D6J7d%2Bu4o9uQL3YazNFyosQ036QePE1bdBzpXoAp4MzVcg%40mail.gmail.com.
For more options, visit https://groups.google.com/d/optout.
