For what it is worth, the issue reported in Alex's original post was fixed in Maple 12:

> int(a,t=-Pi/4..Pi/4);
                                     1/2
                                    2    Pi
                                    -------
                                       8


> int(aa,t=-Pi/4..Pi/4);
                                     1/2
                                    2    Pi
                                    -------
                                       8

> evalf(Int(a,t=-Pi/4..Pi/4)); identify(%); 
                                 0.5553603673

                                     1/2
                                    2    Pi
                                    -------
                                       8

> evalf(Int(aa,t=-Pi/4..Pi/4));             
                                 0.5553603673

John

Engineering clean and maintainable replacements to artistic code that is more-or-less fully backward compatible with the old code is an especially entertaining pursuit.   It involves playing a lot of the game that one of my co-workers lovingly calls "Whack-a-Mole" with the regression test database.

John

Engineering clean and maintainable replacements to artistic code that is more-or-less fully backward compatible with the old code is an especially entertaining pursuit.   It involves playing a lot of the game that one of my co-workers lovingly calls "Whack-a-Mole" with the regression test database.

John

[citation needed]

I'd be interested to see numbers. I've read a couple things to indicate that initial Vista sales were pretty good compared to XP but that overall adoption is not.  The relevant wikipedia entry seems to be in the middle of a neutrality dispute however.

John

Jonathan Coulton played this song at his live show in Toronto last night.  It was quite excellent.  Based purely on t-shirts in the audience, there was a pretty strong math nerd showing.

John

If you are looking for something more efficient than if/then, goto is probably not it.  I am fairly certain there is a reason that Maple's goto is undocumented and, as far as I know, not used anywhere in the library.

John

If you are looking for something more efficient than if/then, goto is probably not it.  I am fairly certain there is a reason that Maple's goto is undocumented and, as far as I know, not used anywhere in the library.

John

3- Actually if you type x_0  in 2D math, it will be turned into x[0].

Going back to this thread: http://www.mapleprimes.com/forum/indices
If you type x<ctrl>_0 it will create something that is rendered as a subscript, but is not an indexed variable (it is actually `#msub(mi("x"),mn("0"))` - the same as executing 'convert to atomic identifier' on it) .  A third option is to type x\_0 to get x_0 literally, but that will not get rendered as a subscript in 2D.

John

This behavior of solve (which started in Maple 5.4) helps to confuse the issue:

solve(x-3<0, x);          
                         RealRange(-infinity, Open(3))

John

This is an interesting idea.

However, in this case, it is entirely possible that solve is even doing "all" the work.  Putting a trace on solve before executing these commands shows, for example, solve is being called:

solve(ln(x)-1/2*ln(1+x^2)-1/x*y(x)+
   1/2*ln(1/cos(y(x)-arctan(x)+_C1)^2)-_C2, {y(x)});
solve( x/(1+x^2)^(1/2)/exp(1/x*y(x))*(1/(cos(y(x))/(1+x^2)^(1/2)
   *cos(_C1)+cos(y(x))*x/(1+x^2)^(1/2)*sin(_C1)+sin(y(x))
   *x/(1+x^2)^(1/2)*cos(_C1)-sin(y(x))/(1+x^2)^(1/2)
   *sin(_C1))^2)^(1/2)/exp(_C2)-1, y(x));

And those seem almost as complicated as the original problem.

John

Shuhong's paper on multivariate factoring via PDEs is great, but a slighly funny example here.  The PDE in that paper is apparently pretty strange (notwithstanding the fact that it is considered as being defined over finite fields!), and for the purposes of the algorithm it is instantly turned into a matrix - so it is not actually using any of the theory of PDEs.  I suspect most of the reason for putting 'PDE' in the title is was to make it eye catching.

John

Instead of either an indexed name or an unevaluated function call, why not just use a symbol?  In this case u_t  (in 2-D math, type as u\_t) gives pretty much the same meaning visually without any of the extraneous semantic baggage.

As far as I can tell, people end up using index names because it is easy to generate an arbitray number of them.  But, in fact it is just as easy to do with the 'cat' operator || :

seq(`u_`||i, i=[$1..5, t,s,v]);
                    u_1, u_2, u_3, u_4, u_5, u_t, u_s, u_v

John

Instead of either an indexed name or an unevaluated function call, why not just use a symbol?  In this case u_t  (in 2-D math, type as u\_t) gives pretty much the same meaning visually without any of the extraneous semantic baggage.

As far as I can tell, people end up using index names because it is easy to generate an arbitray number of them.  But, in fact it is just as easy to do with the 'cat' operator || :

seq(`u_`||i, i=[$1..5, t,s,v]);
                    u_1, u_2, u_3, u_4, u_5, u_t, u_s, u_v

John

The error message is not the most helpful, but here is the main problem.  'series' (as called by collect) has to establish the independence of the various expressions for which is uses  something like 'depends':

depends(u[t],u);
#                                     true
depends(u[t], u[1]);
#                                     false

A pretty standard work-around to this is to temporarily replace the indexed symbols with new symbols:

expr:=u*(u[t]+1):
depends(u||t, u);
#                                     false
subs(u[t]=u||t,expr);
#                                  u (ut + 1)
collect(%, [u||t,u]);
#                                   u ut + u
subs(u||t=u[t],%);
#                                  u u[t] + u
# or on one line:
subs(u||t=u[t],collect(subs(u[t]=u||t,expr), [u||t,u]));        
#                                  u u[t] + u

John

The error message is not the most helpful, but here is the main problem.  'series' (as called by collect) has to establish the independence of the various expressions for which is uses  something like 'depends':

depends(u[t],u);
#                                     true
depends(u[t], u[1]);
#                                     false

A pretty standard work-around to this is to temporarily replace the indexed symbols with new symbols:

expr:=u*(u[t]+1):
depends(u||t, u);
#                                     false
subs(u[t]=u||t,expr);
#                                  u (ut + 1)
collect(%, [u||t,u]);
#                                   u ut + u
subs(u||t=u[t],%);
#                                  u u[t] + u
# or on one line:
subs(u||t=u[t],collect(subs(u[t]=u||t,expr), [u||t,u]));        
#                                  u u[t] + u

John