Nicholas Kinar wrote:
However, as the output shows below, the term p(1,
2)**n/(deltat**2*deltax**2) is still on the LHS of the expression, to
the immediate left of the == sign. As I understand, the
If you use master it all works. IndexedElement is now called IndexedBase (but
you weren't
Aaron S. Meurer wrote:
While you are doing that, I have one question. You state that trial
division is faster than the more advanced algorithm in factorint.
Have you throughly tested this with timings? This is a sensitive
part of the code, so I only want to make sure that it is as fast as
Bastian Weber wrote:
Mateusz Paprocki wrote:
Make sure you set the domain via a keyword argument, i.e. you
can't write Poly(..., t, 'EX') because then 'EX' is treated
as a symbol, not a domain.
If you want to get all coefficients wrt symbol 't', then:
In [2]: Poly(3.5*a + cos(b)*t,
def generate_fdtd(expr, nsolve):
w = Wild('w')
expr0 = expr.lhs - expr.rhs
expr1 = expr0.expand()
expr2 = collect(expr1, w**nsolve)
expr2 = expr2.expand()
Why are you expanding after you collect? This will undo what you just collected.
As Oyvind says, when you are
Ah, you are right, Chris; thanks for pointing this out.
the function again with a simpler expression:
expr1 = Eq(p[3,1]**(n+1) + p[2,1]**n, A*p[3,1]**(n+1)*p[3,3]**n -
p[3,3]**n)
Ahh...much nicer!
So thank you very much, Oyvind and Chris, for taking a look at this
code, since I
Nicholas Kinar wrote:
on the mathematics rather than dealing with algebraic re-arrangements.
I can vouch that trying to do similar things with a proprietary CAS
would be more difficult. These proprietary systems lack both the
functionality and the great user community.
I remember when I was
p.s. There is a less robust module discussed at
http://code.activestate.com/recipes/535164-error-propagating-class-for-uncertain-numeric-quan/
It is perhaps worthwhile to read to become aware of some of the issues.
/c
--
You received this message because you are subscribed to the Google
Ahhh...I haven't gotten used to noticing the **foo** being interpreted as bold
by my OutlookExpress. I see that the y*2 and e*2 should actually be y**2 and
e**2.
The comments I made still apply and the only difference is that the two values
of y should be substituted into eq3. Doing so yields
Chenjie Gu wrote:
Thanks, make_list works!
Now my code becomes
y = x0 * x1 * exp(40*x0)
non_poly_terms = [a for a in make_list(y, Add) if (not
a.is_polynomial())]
print non_poly_terms # [x0*x1*exp(40*x0)]
non_poly_terms = [a for a in make_list(non_poly_terms[0], Mul) if
(not
One thing I've liked about wikipedia is the ease at which you can branch off to
look at a topic of interest. I wonder if we might hotlink some of the modules
listed in Features to their corresponding docs page. So if someone were
interested in the geometric algebra, they could easily go to the
Aaron S. Meurer wrote:
Shouldn't the second argument of Order be the variable. It seems
like using this also for some kind of linear change is ambiguous at
best. Anyway, I didn't see any uses of it using git grep --color
O(.*,.*).
It was uncovered code. I don't know what the purpose of
Ondrej Certik wrote:
On Mon, Nov 15, 2010 at 10:42 PM, Aaron S. Meurer
asmeu...@gmail.com wrote:
Actually, where is the source for SymPy live? The source link points
to the old sympy.org page that doesn't exist anymore, and I don't
see it on the Github user sympy.
I just put it here:
Filip Dominec wrote:
On Nov 18, 7:02 pm, Mateusz Paprocki matt...@gmail.com wrote:
it can be easily extended
to support rational functions and absolute values (somewhere I have
preliminary code for this).
Cool. Right now I am using sympy to solve some calculations for
geometrical optics.
I don't see 1694B there, only 1694 and 1694cov.
Sorry. It's there now.
/c
--
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
My t2 branch has a gcdfactor method for matrices that can remove any gcd's from
terms if that would be helpful:
This is in commit 1811 and 1811b
+def test_gcdfactor():
+from sympy.abc import a, b, c, x
+m=Matrix(((a/x, b/x), (1/x, c/x)))
+assert m.gcdfactor() == 1/x
+assert m ==
Øyvind Jensen wrote:
fr., 19.11.2010 kl. 10.24 -0800, skrev Julien Rioux:
Hi all,
How can I tell the fcode printer to print integers and rationals as
reals?
Thanks for spotting this.
I think the code printers should by default assume floating point
division, as the generated code
You were fast! That means you already have a patch and I don't have
to do it?
I had already spent a lot of time in that section of the code and was
interested to see how to use another feature that I knew was there. I guarantee
there will be other opportunities -- see our Issues list for
Aaron S. Meurer wrote:
Also, you have a bare except! (and while your at it, I would put in a
comment explaining that fractions is only available in Python 2.6+)
Knowing you would say so, I did actually look up the likely error, but forgot
to put it in. Other changes have been made.
/c
--
Ronan Lamy wrote:
It looks good on the sympify() front, but why don't you just use
Rational(x.numerator, x.denominator)?
I'm always stymied by the import issue. But I realized I can import C
successfully and use Rational through that, so that change has been made.
/c
--
You received this
Filip Dominec wrote:
Alternatively we may leave sympify untouched and use 'simple()'
instead of 'simplify()'. I write this function quite often and every
byte counts.
But that would be misleading since the function has nothing to do with making
things simple. It makes them into sympy object.
Aaron S. Meurer wrote:
I would like to get SymPy 0.7.0 released before my classes start
again in a few weeks. From what I see, these are the things we need
to do before releasing:
I would like to see the as_coeff_factors and as_coeff_terms be changed to
as_coeff_addterms and
Aaron S. Meurer wrote:
I would like to get SymPy 0.7.0 released before my classes start
again in a few weeks. From what I see, these are the things we need
to do before releasing:
- Merge in Mateusz's polys branch. See issue 2133. Mateusz and I
are currently working on getting this
Ondrej Certik wrote:
Hi,
I am officially passing the leadership of the SymPy project to Aaron
Meurer.
Congrats, Aaron!
My vision with SymPy has always been to make symbolic manipulation in
Python easy and fun. So myself I will concentrate more on creating a
web service around sympy,
Is there a reason not, as in Add, Mul, etc..., to just have one word and use
the evaluate=False to control what happens to it?
Mul(2, 1 + x) - 2 + 2*x
Mul(2, 1 + x, evaluate=0) - 2*(1 + x)
Integral(x) - x**2/2
Integral(x, evaluate=0) = Integral(x, x)
Sum(x, (x, 1, 3)) - 6
Sum(x, (x, 1, 3),
Aaron S. Meurer wrote:
According to the docstring, euler_maclaurin is only an approximation
method.
OK...so in some cases (polynomial with positive exponents?) eualer_maclaurin
will be exact. But when the summand is not of that form you are only going to
get an approximation -- even if the
Just a note: I sent the following via email and see that all quoting was
stripped...and unindented code looks like quotes (having leading chars). So
if you are replying via email to issues you should be aware of that. (I should
start jotting these things down for newcomer reference.)
I can
Aaron S. Meurer wrote:
There is something wrong with your rebasing procedure. You are trying
to rebase the commits that are already in master for some reason.
What exact commands are you using to rebase?
Let's say I have about 6 commits that I want to rebase. I have shortcuts for
11, 22, 33
Øyvind Jensen wrote:
sø., 16.01.2011 kl. 07.14 -0800, skrev smichr:
The branch jeger/fix_doctests3 does not raise any errors under win32.
However, rewriting the test is a shallow fix of the problem which
appears to be that -Object.method has tigher binding on the negation
that it does on the
Øyvind Jensen wrote:
As you pointed out in the other post, the constructor has some
redundant
lines and the cleanup you suggest works. Are you going to place a
pull request?
sure...I'll put it in with 1917's pull
/c
--
You received this message because you are subscribed to the Google
Right, but you can't use it in non-interactive mode, can you ?
As Ondrej suggested, parsing the file is one way to go. And python is great for
that type of parsing:
from sympy import *
s='model = {\n equations: [\n a + b + c =e= 1,\n
exp(i*pi) =e= -1\n
Jeff Pickhardt wrote:
Sympy has sympy.pi and sympy.I, however Euler's constant is found via
sympy.exp(1).
I suppose the reason that E rather than e is available is to keep it from
clashing with commonly used lowercase symbol names. But since pi is a lower
case constant I would think that
Ronan Lamy wrote:
Le mardi 18 janvier 2011 à 19:44 -0800, smichr a écrit :
When requesting the series of cos(x) I wouldn't expect to see cos()
terms in the result, but the default behavior does this.
Why not? Obviously, the value of cos(x) for x=1 is cos(1), so that's
going to be the first
Vinzent Steinberg wrote:
I thought bounded is meant with respect to +-oo, so if x is an
infinitesimal, for any eps 0 we have abs(x) eps, and thus it is
bounded. If bounded also applies with respect to 0, I don't
understand how it could be useful.
I was just trying to rationalize why it
Aaron S. Meurer wrote:
There is is_finite too? Is this just a duplicate of is_bounded?
See the truth table I posted below. is_finite is used (perhaps erroneously) to
tell about infinitesimals.
/c
--
You received this message because you are subscribed to the Google Groups
sympy group.
To
Fredrik Johansson wrote:
Hi all,
Version 0.17 of mpmath is now available on the project website:
http://code.google.com/p/mpmath/
Hi Fredrik,
Something I noticed in mpmath files (in sympy) was the use of _ in files. For
some reason I recall that this should probably be removed with a del _
Fredrik Johansson wrote:
Hi Chris,
On Wed, Feb 2, 2011 at 6:18 PM, Chris Smith smi...@gmail.com wrote:
Something I noticed in mpmath files (in sympy) was the use of _ in
files. For some reason I recall that this should probably be
removed with a del _ command. This use was located in libmpf
By the way, when I attempt:
factor(d)
I get:
PolynomialError: Can't decompose exp(C3)
I was using my casy branch at github (smichr acct).
/c
--
You received this message because you are subscribed to the Google Groups
sympy group.
To post to this group, send email to
Dox wrote:
Hi everyone!
I'm new around here, so excuse if my questions are not that clever
:-P
I was checking the relativity sheet designed by Ondrej
https://github.com/sympy/sympy/blob/master/examples/advanced/relativity.py
and when I run it the output doesn't show the Greek letters as
Alexey U. Gudchenko wrote:
I have tested base series work-flow (which was interesting to me) and
present result.
All test produced relative to the latest smichr/2084 branch, because
master branch has a huge of errors. I have not tested very complex
cases, because in simple cases issuses
These methods mostly give their answers in terms of series, so if
anyone could tell me how to go from series - respective function
(if it exists), it would be great.
I've been working on the series in sympy and though I personally don't know the
methods for this, Alexey just mentioned the
((1+x)**7).series(x, n=3)
1 + 7*x + 21*x**2 + 35*x**3 + 35*x**4 + 21*x**5 + 7*x**6 + x**7
but expected:
1 + 10*x + 45*x**2 + O(x**3)
h[1] ((1+x)**7).series(x, n=3)
1 + 7*x + 21*x**2 + O(x**3)
abs(x + x**2).series(n=1)
x + x**2
but expected:
class f(Function):
pass
The error is also seen when trying to find whether f(10).is_positive:
f = Function('f')
f(10).is_positive
[...]
RuntimeError: maximum recursion depth exceeded
I have a branch named DetectCycle at github that has a patch fixing this.
[
OK, these are now working:
h[1] f=Function('f'); f(x).series()
Traceback (most recent call last):
File stdin, line 1, in module
File sympy\core\expr.py, line 852, in series
s1 = s._eval_nseries(x, n=n)
File sympy\core\function.py, line 299, in _eval_nseries
Ronan Lamy wrote:
h[3] abs(x + x**2).series(n=2)
x + O(x**2)
This is wrong: abs(x) = -x when x 0, so abs(x) - x is obviously not
O(x**2) when x0.
But the series is being calculated from the positive direction;
if you are leaving out the x**2 term, isn't this O(x**2)?
h[9]
Julien Rioux wrote:
Dear list,
I found some more problems when using non-commutative symbols and
subs and I wonder if I should reopen issue 2022 or open a new issue?
Before the changes of 2039 you would get:
h[2] (a*A).subs(a*a*A,B)
Traceback (most recent call last):
File
Brian Granger wrote:
They are both trying to print Ket('psi') which (on my system) generates
print Ket('psi')
|psi
print pretty(Ket('psi'))
u'\u2758psi\u27e9'
Yes, this would help us to debug this. Also, what OS are you on?
Windows XP
Do you have pretty printing
On Tue, Feb 15, 2011 at 10:55 PM, Aaron S. Meurer asmeu...@gmail.comwrote:
On Feb 15, 2011, at 6:05 AM, Ronan Lamy wrote:
h[10] Derivative(exp(x).series(), x).doit()
1 + x + x**2/2 + x**3/6 + x**4/24 + O(x**5)
Wrong: the derivative of a O() term can be arbitrarily large.
First, I don't see how changing `O(x**2)` to `O(x)` says anything about how
large that term might be. The only difference is in the rate at which it is
growing. But I would agree that O(1) should not become 0. On the other
hand...
Doesn't it matter that one is differentiating the series
By themselves, Order terms aren't required to be of the form O(x**n).
What should appear in the return value of series() is another matter,
which depends on the exact purpose of the method. According to its
docstring, it's supposed to return the Laurent series of the function,
so it's only
No, exp(1/y) is O(1) for x going to 0, so you can't say that diff(O(1,
x), y) is 0.
Do you mean exp(x/y)? When I try the expansion of that in master for n=2 I
get: `1 + x/y + O(x**2/y**2, x, y)`. And for n=0 `O(1)`. Now I can see a
problem. There is no variable stored with O(1). It is
No, that's not exactly what it means (cf.
http://en.wikipedia.org/wiki/Big_O_notation ). 'cos(x**2) = O(1)' (it
should more properly be written 'cos(x**2) in O(1)') means that
cos(x**2)/1 is bounded near x=0.
After looking again, can I say O(1) means you will never be more than a
constant
|f(x)| = M |x|
so this by itself says *nothing* about the derivative, and Ronan's
example shows why.
I really think we need to differentiate between f(x) and s(x), the series
representation of f(x) in some order. There are many f(x) that can be
represented by a single s(x) so I don't
Ondrej Certik wrote:
On Tue, Feb 15, 2011 at 9:07 PM, Ondrej Certik ond...@certik.cz
wrote:
On Tue, Feb 15, 2011 at 9:03 PM, Ondrej Certik ond...@certik.cz
wrote:
On Tue, Feb 15, 2011 at 7:26 PM, Chris Smith smi...@gmail.com
wrote:
f(x)| = M |x|
so this by itself says *nothing
Is there someway of querying if unicode greek symbols are enabled in
sympy?
See pretty_symbology and pretty. pretty.py imports pretty_use_unicode and uses
it in pretty() to decide what to print. pretty_symbology imports pretty() as
xpretty() so it's tests don't fail.
Hopefully that will
I don't know what all the problems are that systems run into, but as you see:
it happens. So I tend you lean on the CAS as an aid for the tedious part.
First, I get rid of the Reals and replace them with Rationals. I also throw
away the denominators which, in this case, do not contain any
Ronan Lamy wrote:
Le mercredi 16 février 2011 à 22:24 -0800, Ondrej Certik a écrit :
2) NumPy array()
So that you can use syntax like:
xdata = array([1, 2, 3, 4, 5])
ydata = xdata ** 2
data2 = array([xdata, 1.5 * ydata])
which just works in Mathematica (it's in the core language).
In [8]: TableForm([[5, 7], [4, 2], [10, 3]],
...: headings=[[Group A, Group B, Group C], [y1,
y2]],
...: alignment=right)
Out[8]:
| y1 y2
---
Group A | 5 7
Group B | 4 2
Group C | 10 3
I like it! One thing that I do with my ASCII
Vinzent Steinberg wrote:
1) Like Robert's Rules of Order, before beginning to make a solution
for an issue, seek a second for your motion. That affirmation
would indicate that someone thinks your proposal for a solution is
worth pursuing.
This is a general rule, it correlates with release
Vinzent Steinberg wrote:
Anyone else have ideas along this line?
I think it would make sense to create a directory in sympy for such
stuff. sympy/utilities comes to my mind, but maybe it is already
overloaded. Maybe sympy/addons?
If people start using it a lot, it can be moved to the
print sqrt(sin(x)).series(x)
x**(1/2) - x**(5/2)/12 + x**(9/2)/1440 + O(x**6)
print sqrt(sin(x)).series(x, 0, 12)
x**(1/2) - x**(5/2)/12 + x**(9/2)/1440 - x**(13/2)/24192 -
67*x**(17/2)/29030400 - x**(21/2)/5677056 + O(x**12)
which I think *is* correct. But it might make sense to return
Filip Dominec wrote:
In my opinion the best way would be if some branch-maintainer reviewed
the contributions and added them in one branch manually.
The cookbook approach could work. gist, perhaps? I don't really know how to
access the history of gist pastes/snippets, however. Something like
Alexey U. Gudchenko wrote:
19.02.2011 04:18, Chris Smith пишет:
Ondrej Certik wrote:
...
We definitely need to calculate Laurent series. Example: e = x *
sin(1/x)
1) e.series(x, 0, 10) should raise an exception.
2) e.series(x, oo, 10) would return the first 10 terms of the
Laurent
Kate wrote:
In any case, I need this behavior, so I'll be doing it for myself
regardless. I'd like to contribute it back to the community, but if I
end just using my patched version in my application, then it still
won't have been in vain.
OK...in any case, it's a way to become familiar with
Ronan Lamy wrote:
Also while writing it, I've noticed 2 additional problems with
Expr.series:
* The order is off by one.
* Its name is misleading since it doesn't return a series.
Can you give examples? In 2084 I get:
cos(x).series(n=3)
1 - x**2/2 + O(x**3)
terms valid up TO n=3
Ronan Lamy wrote:
Le mercredi 23 février 2011 à 09:40 +0545, Chris Smith a écrit :
Ronan Lamy wrote:
Also while writing it, I've noticed 2 additional problems with
Expr.series:
* The order is off by one.
* Its name is misleading since it doesn't return a series.
Can you give examples
in the new polys12 branch) since it's picky in that regard.
This should be fixed.
Aaron Meurer
All in polys12:
h[2] f = 4*x**4 + 8*x**3 + 77*x**2 + 18*x + 153
h[2] factor(f)
(9 + 4*x**2)*(17 + 2*x + x**2)
h[3] factor(f,gaussian=1)
(9 + 4*x**2)*(17 + 2*x +
And (as I understand Ronan's tendency) if we can't provide O(x) then
we can't provide asymptotic expansion upon the whole. (only some terms,
that generally speaking is neither asymptotic expansion, nor
An order term is always returned now.
Until we can represent O at x0!=0 the origin is
Ronan Lamy wrote:
Le vendredi 25 février 2011 à 16:26 +0545, Chris Smith a écrit :
Alexey U. Gudchenko wrote:
25.02.2011 08:59, Alexey U. Gudchenko пишет:
Conversely, internal calling of series method therefore must be with
option (..., something_hack=True) if it options is needed
Ronan Lamy wrote:
Why f.e. this variant:
h[2] cos(x).series(x,1,n=2)
(1 - x)*sin(1) + cos(1) + O((x - 1)**2)
is bad ?
What's bad is that '(x - 1)' in the O() is actually a symbol that's
completely unrelated to x. This could be very confusing and it's
unlikely that such
I just found that the key to getting the failing recurence test to work is to
educate Add's flatten about the unexpected undistributed Number. See add.py in
my branch if you you are interested. All tests in that branch now pass. If
that's working, then perhaps all that would remain is adjusting
Aaron S. Meurer wrote:
Other classes will be different, but Integral is going to have a
special structure whenever I finish the Risch Algorithm (because it
can prove that integrals can't be done).
But what I'm suggesting is that after doing a subs -- the thing that cause the
problems for
Aaron S. Meurer wrote:
basic=True is supposed to be a way for other classes to implement
expand() functionality that doesn't match any other hint (see the
docstring of expand()). Its name comes from Basic(). So we should
use a different hint name, I think.
But I do agree that we could
Ronan, perhaps we can come to some common language for this issue. I would
summarize my sentiments as
When in shark infested waters, first stop the bleeding, then swim carefully to
safer waters.
There are many bleeding issues that have been fixed with this work. We are
still in shark
Remove the 'sudo' option.
Everything else looks good to me - though I'm sure that given enough
time, I could still find a few reason to nitpick.
OK, thanks. I will make that change. Could you (or anyone else) please focus
your nitpick skills on the use standard O term commit? I think when
Julien Rioux wrote:
if reeval:
-return Mul.flatten(c_part)
+return Mul.flatten(c_part+nc_part)
return c_part, nc_part, order_symbols
The reeval is only needed to update the c_part. So instead of returning right
away it would be better to update the
Kate MacInnis wrote:
...
Another unexpected one was this:
In [6]: (((x**2*y**4)**a)**(x*y))**3
Out[6]:
3
⎛ x⋅y⎞
⎜⎛ a⎞ ⎟
⎜⎜⎛ 2 4⎞ ⎟ ⎟
⎝⎝⎝x ⋅y ⎠ ⎠ ⎠
In [7]: powdenest(_)
Out[7]:
6⋅a⋅x⋅y
⎛ 2⎞
⎝x⋅y ⎠
instead of the
3⋅a⋅x⋅y
⎛ 2 4⎞
⎝x ⋅y ⎠
that the test wants. Is there some reason
Matteo wrote:
I will try to search if sympy has some
conversions rules from trig to exp formulas, and maybe viceversa.
h[2] cos(2*x).rewrite(exp)
exp(-2*I*x)/2 + exp(2*I*x)/2
--
You received this message because you are subscribed to the Google Groups
sympy group.
To post to this
Aaron S. Meurer wrote:
I don't know what Mathematica's Eliminate does, but it seems to me
that the solve() line below should just work, without the user
having to consider what kind of solving procedure is necessary to
solve it.
It's more subtle than that: if I say that `a + 3*b = 0` and
Bastian Weber wrote:
Hello,
I think I found a bug. Calling .count_ops() on an expression
containing a derivative raises a NameError.
In [ https://github.com/sympy/sympy/pull/23 ], which is awaiting final review,
this yields:
h[1] f(x).diff(x).count_ops()
2
h[2]
SherjilOzair wrote:
Thank you Mr Aaron,
Many issues like issue 754 which interest me, but when I try to
reproduce the error, It's already fixed.
Yes...the last few comments of the issue state the same. The thing to do (that
is easy) is to add the expressions that used to raise errors to the
SherjilOzair wrote:
Please direct me to easy-to-fix issues that have NOT been solved.
I was also wondering if I could do a small part of the project ideas
on the ideas page.
You might check any of the following:
2213, 2180, 2172, 2151, 2013, 2012, 2011, 1991, 1935, 1931, 1743, 1727, 1621,
SherjilOzair wrote:
Mr. Ronan,
You've been a great help. Please help me start up my suggesting me a
small project or patch.
I would be very grateful.
Issue 2180, 2198 or 2200.
--
You received this message because you are subscribed to the Google Groups
sympy group.
To post to this group,
Hector wrote:
On Fri, Mar 18, 2011 at 4:57 AM, Aaron S. Meurer
asmeu...@gmail.com wrote:
For issue 2200, we didn't decide if limit(sin(x), x, oo) should
raise an error or should return nan (or something else).
Hello everyone,
Hi Aaron, I was wondering why limit(sin(x),x,oo) should
Actually, SymPy computes limits from a single direction (from the
right by default). I think there was an issue once to implement
limit from both directions (it would basically check '+' and '-' and
return the result only if they matched), but I can't find it now.
You have a better memory
Aaron S. Meurer wrote:
On Mar 28, 2011, at 10:01 PM, smichr wrote:
You say:
In particular there is currently no
(good) way to interpret the result of e.g. limit(Wild('a')*x, x,
oo)
as being infinity (to the end user a*oo is visibly infinity,
but
(a*oo).is_unbounded is None)
Aaron S. Meurer wrote:
Actually, any repo collaborator (i.e., anyone with push access to
the repo) can edit *any* comment, regardless of who made it.
I'm just wondering because I personally don't have any difficulty
keeping track of this stuff, so if others (like you) do, I'm
wondering if
By the way, another thing to remember about editing comments is that
no notification is sent to anyone for an edited comment (I don't know
if this applies if you add @username in an edit). Notifications are
only send for new comments. So if you want someone to know you have
commented on the
Dave wrote:
Hello,
I'm relatively new to SymPy. I'm using it to verify some of my
algebraic manipulations. I have the following expression I'm trying
to
simplify:
1 3*Y
- +
Ondrej Certik wrote:
I don't think we should merge things into master, if it means making
it more difficult to merge the branch. We should do whatever it takes
to get this in, using our manpower.
I'm not following the vocabulary nuances here. What do you mean by not
merg[ing] things into
should be all backwards compatibility breaks. Let's start a wiki
page for this. Everyone could help...
When the page is up, perhaps you could put the short SHA1 with commit titles
(the short log form) and we could check out ranges so we aren't duplicating
efforts.
/c
--
You received this
FWIW, there are 1242 commits since 0.6.7. The first one's short SHA1 is ad626a6
/c
--
You received this message because you are subscribed to the Google Groups
sympy group.
To post to this group, send email to sympy@googlegroups.com.
To unsubscribe from this group, send email to
Vinzent Steinberg wrote:
On 12 Apr., 21:53, Chris Smith smi...@gmail.com wrote:
Also, regarding limit order. Although I don't (due to limited
insight) understand how changing the limits changes the
computational difficulty of the integral, the integral is not being
performed when doing
Aaron S. Meurer wrote:
There seem to be a lot of unrelated changes in the pull. Which
commits specifically are you referring to?
3c471f8 2111: log, tan and cot return zoo; zoo+b and zoo*b - zo
--
You received this message because you are subscribed to the Google Groups
sympy
Tom Bachmann wrote:
nseries does two things:
1) If you specify an argument, if the expansion point is zero, and if
the expansion direction is + then it directly calls _eval_nseries,
and works in the best effort way as described above.
2) Otherwise it just calls series.
Contrary to what I
One other thing that might be resolved is the as_coeff_Mul() (meaning, give me
the leading Number from expr when treating it as a Mul and the rest as a Mul)
method which is confusingly close to as_coeff_mul() (meaning, give me the
leading Number from expr when treating it as a Mul and give me a
Frédéric Grosshans-André wrote:
Another strategy seems possible, and I think, simple enough for me to
program. However, I'm not a programmer, and I don't know sympy well
enough to know if my idea is stupid or not.
I think about a parameter to series() to manually tell it should only
return
You may have not requested an explicit set of symbols and are
willing to take whatever you get...in that case you need to know
what you got.
h[2] solve([x+y-3,x**2+y-5])
[(-1, 4), (2, 1)]
But that's just an unsafe convenience that should really only be used
in interactive
Frédéric Grosshans-André wrote:
Le mardi 26 avril 2011 à 11:38 +0545, Chris Smith a écrit :
Haz wrote:
If the solutions to solve are uncountable then you can't yield an
infinite number of dictionaries, each corresponding to one of the
infinite solutions since some solutions will never
On Tue, Apr 26, 2011 at 3:09 PM, Alexey U. Gudchenko pr...@goodok.ruwrote:
26.04.2011 08:20, smichr пишет:
can tests involing warnings be put in doctests rather than the test
suite?
I prefer not to see warnings while running tests. Would it be a better
idea to put these in docstrings?
On Tue, Apr 26, 2011 at 11:30 PM, Alexey U. Gudchenko pr...@goodok.ruwrote:
26.04.2011 19:24, Haz пишет:
What about having our own (light) warning functionality -- goes to
standard
out under normal circumstances, and any testing can (and probably should)
disable the output of the warning.
1 - 100 of 1298 matches
Mail list logo
