MultiSeries is built on sound theory.  asympt was, well, built; it works for the easy cases, but fails badly once you get outside a certain safe core.  Your problem is definitely outside that core.

It works in Maple 18.  It definitely does not in 16 (I don't have 17 at hand).  So I am guessing that it is a new feature of Maple 18.

I could not find when it was introduced from the What's New pages either.  This is a nice feature, why is it so hard to find?

inttrans[fourier](1,x,p) gives the answer you want.  I don't think you will be able to coerce int itself to give that answer.

There is essentially no chance that this will be solvable in closed-form.  It involves too many exponentials at different scales.

If you had values for some of your constants, especially S0 and R4, that might help.  In some cases (say S0=1/2, R4=1) you can get an 'closed-form' (as a RootOf).

Generating a decent numerical solver specialized for your equation might be fun.

Ok, so the typesetting on the old mapleprimes was always fairly poor (and somehow seemed to degrade over time).

Now, not only is it much much worse (those images have some of the worst typesetting I have seen in a very long time), the usability has essentially completely disappeared!  Typesetting on the web has, in the past year, taken a huge leap forward with both jsMath and MathJax.  Why on earth did MaplePrimes take a huge leap backwards???

Have you guys ever heard of 'use cases'?  If you had figured out what the standard work-flow was for visitors to MaplePrimes, you would have figured out that Maple Documents/worksheets are not the 'solution' to anything in this particular case.

Ah well, it seems that the signs are clear: I should disappear from here again, and go hang around 'modern' sites again, places that understand the usage patterns of their community and what technologies 'work'.  I'll come back when MaplePrimes has caught up with current web usability patterns and technology usage. 

The best answer to your question is actually: it is not a good question to ask.  By this I mean that, if you're asking, you are not programming in Maple but by bringing in baggage from a lot of other languages instead.  For example, this question makes little sense in Java or in Python, and none at all in Prolog (or ML or ...).  You need to try to learn 'Maple' and forget the low-level details of those other languages which cloud your understanding.

If you want to get a deeper understanding of Maple, the programming guides are one place (but they are hopelessly out of date!).  You might want to go over my Maple 401 post from a long time ago to get started.  I don't claim it's all that up-to-date, but it's a start.

f := proc(x::Not(assignable)) ... end

One caveat: `type/assignable` is a library-level rather than a kernel-level type, which do not work in as general a setting. You might want to go with something less thorough and do simply

f := proc(x::Non(symbol)) ... end

There is no way to export even a platform-specific program from a Maplet.

Now, if your potential users can be assumed to have Maple, then there are indeed ways to export a Maplet so that it is runnable independently -- the Maple Calculator is in fact an example of that.  I believe that files with a .maplet extension are run as maplets by Maple.  But this is probably not what you're asking for.

As far as I can tell, diff(G(z(s,t), w(s,t),[s$m,t$n]) does what you want (with m, n non-negative integers).  Have you tried that?

If we know where this sum is from, that might help us.  In the form you give it, there is very little chance it will have  a closed-form.  The one thing I did not have a chance of trying is to see if 1/(1+(1+1/n)^(1/3)) has a nice series development.  If it does, you might be able to switch the order of the two sums and you might get lucky.

I use the listings package for code in LaTeX (I have never felt the need to show Maple sessions in my papers).  Put

\usepackage{listings}

and then

\lstdefinelanguage{maple}
	{morekeywords={true, false, try, catch, return, break, error, 
	               module, export, local, option, in, use,
                 and, or, not, xor, xnor,
                 if, then, elif, else, fi,
                 while, for, from, by, to, do, od,
                 proc, nargs, local, global, end, NULL}}
\lstset{language=maple, basicstyle=\small\ttfamily

after your \begin{document}. The listings package has a huge number of useful options which are really handy for displaying code.

From all I know (as a small [now ex-]shareholder and recent discussions with Maplesoft executives), her answer was not just a 'political' reply, but the actual expectations of Maplesoft employees of what will happen for the next several years.

Without the actual equation, we really can't help.  Post a link to a worksheet, that's the best way to communicate long equations in such a way that others here may be able to experiment with it.

The time-honoured way to replace a protected routine is to do:

mysin := eval(sin); unprotect(sin); sin := proc(x) mysin(Pi*x/180) end;

Of course, this won't behave "quite right" since procname gets affected and printing gets mucked up -- but the advice above on printing can deal with that. Note that using an export from a module (and then 'with') to shadow a top-level name is safer, since that won't affect :-sin, but it too has its quirks.

First, notice that we can extract a term like ln(x)*ln(1-x)^2 by differentiating a simpler function wrt its arguments:

> diff((1-t)^k*t^n,n,k,k);

                            k          2  n
                     (1 - t)  ln(1 - t)  t  ln(t)

So we obtain what we want for k=0=n. But before doing that, let's integrate our original term:

> int((1-t)^k*t^n,t=0..1);

                      GAMMA(k + 1) GAMMA(1 + n)
                      -------------------------
                          GAMMA(n + 2 + k)

and now we can differentiate wrt n and k, and evaluate at 0, and we indeed get:

  simplify(eval(diff(%,n,k,k),[n=0,k=0]));

                                2
                              Pi
                         -6 + --- + 2 Zeta(3)
                               3

With some further work, one can prove that this is indeed valid. Too bad Maple doesn't seem to know this general pattern. I am surprised, as I thought it did!