Your p can be factored as p = (6000 - w^4)*(z*g__u + f*g__z)/144000, so p=0 implies that w doesn't depend on any of the other variables. w = 6000^(1/4), which simplifies to 2*375^(1/4).

y is a name, not a string; "y" is a string, not a name. They are not the same thing.

fx:= 3*x^2 - 9*y:
str:= String(fx);
                       str := "3*x^2-9*y"
has(fx, y);
                              true

evalb(SearchText("y", str) <> 0);
                              true

Why are you converting mathematical expressions to strings? I suspect that there is an easier way to achieve your ultimate goal.

There's no technical reason why those errors are untrappable; the reason is purely philosophical, and it's stated on help page ?try. Here is an excerpt from the 10th paragraph of Description:

• The following exceptions are untrappable:
  - Computation timed out (this can only be caught by timelimit, which raises a "time expired" exception, which can be caught).
  - Computation interrupted (user pressed Ctrl+C, Break, or equivalent).
  - Internal system error (which indicates a bug in Maple itself).
  - ASSERT or return type or local variable type assertion failure (assertion failures are not trappable because they indicate a coding error, not an algorithmic failure).
  - Stack overflow (when that happens, generally stack space is insufficient for doing anything like running cleanup code). This includes the "too many levels of recursion" exception at the Maple language level.

Pick a value of x larger than the stated singularity, say xs. Reformulate the initial conditions to be at xs rather than 0. Call dsolve again. Plot from xs to 10 (or wherever). You may encounter new singularities and need to repeat this process.

orthopoly is an old package, created before modules existed. It is stored in a table. The A:-B syntax works for table-based packages, but apparently proc() uses A; B() end proc() does not.

You have 

for {w = 30..150}
    s:= ...;

How did you come up with that syntax? Change it to 

for w from 30 to 150 do
    s[w]:= ...
end do;  # "end do" can be abbreviated "od"

I used s[w] instead of s so that the results will be saved for each w.

Error messages that are accompanied by a red dashed box result from very basic syntax errors in the command that is currently being entered. They can't possibly have anything to do with code already entered. Thus, this error has nothing to do with piecewise.

You could read the help page ?for. Also, nearly any freely available AI chat assistant will give a reasonable answer to "How do I write a for loop in Maple?"

Here is how I think chaotic IVP solutions should be plotted. Note the use of the options parameters, range, and refine. The differences between these plots and the plots shown in the paper are too categorical to possibly be explained by any accumulation of rounding errors or chaotic process. For example, the second plot below shows only positive values for x(t) whereas the corresponding plot in the paper shows only negative values for x(t).

I've tried several different numeric methods (rkf45, ck45, rosenbrock, dverk78) and different levels of error control (relerr= 5e-6, abserr= 5e-6, relerr= 5e-9), but I got the same plots.

Download DuffingEq.mw

 As always, plots look much crisper in the actual worksheet than they do when the worksheet is uploaded to MaplePrimes.

The command you need is convert(f(x), fullparfrac, x), possibly with added options. See the help page ?convert,fullparfrac.

Maple has a "sum over all roots of a polynomial" feature that usually makes seeing the individual factors unnecessary. However, if that's not useful for you, try including the factor option.

You get much better simplifications by calling dsolve for each numeric instantiation rather than getting a generic solution and then substituting parameter values,

Download DataFRame.mw

If you want to use Dimension, you just need to change uses RationalTriigonometry to uses LinearAlgebra. If you want to use type, you need to put 'Matrix' like that, with unevaluation quotes. That's because Matrix(1,3) is an executable command, not just a type.

(f,g):= <<a|b|c>>, <<d,e,h>>:
type(f, 'Matrix'(1,3)), type(g, 'Matrix'(1,3)), type(g, 'Matrix'(3,1));
                       true, false, true

Unevaluation quotes are not needed for types used in a procedure header:

f:= proc(p::Matrix(1,3)) ... end proc:

To get a Crout decomposition, first get a standard LUDecomposition of the transpose of the coefficient matrix, then transpose each of the returned matrices, then reverse the order that they are multiplied. Although that may seem like a lot of steps, it can all be done in one short command in Maple:

Download Crout.mw

Note the order specified in the output option: ['P', 'U', 'L'] rather than the usual ['P', 'L', 'U'].

You are trying to solve 2 equations for 1 variable. It's not usually possible to get an unconditional solution when there are more equations than variables being solved for. Here are 2 options:

• Add a 2nd variable (of your choice) to solve for,
• Accept a conditional solution.

To add a second variable (for example, Clm):

solve({tau = `&tau;opt`, lambda = `&lambda;opt`}, {w, Clm})

To get a possibly conditional solution, use eliminate instead of solve:

eliminate({tau = `&tau;opt`, `&lambda;opt` = lambdaopt}, {w})

The return will be a list of two sets. The first set is the solution(s) for w (only one in this case). The second set is expressions (only one in this case) that must equal 0 in order for the first set to be valid.

You've made a quite interesting discovery (Vote up): Overloads in modules don't explicitly have option overload, although they do otherwise contain the correct programmatic structure of an overload. So, the workaround for your procedure Isee is to explicily insert option overload when that's needed, like this:

Isee:= proc(a::procedure)
local vp:= interface('verboseproc'= 3), p:= eval(a);
    if op([5,1], ToInert(eval(a)))::specfunc(_Inert_OVERLOADLIST) then
        p:= subsop(3= overload, eval(a))  #op(3,a) is the explicit options
    fi;
    printf("%P", eval(p));
    interface('verboseproc'= vp);
    return
end proc:

There are several things that I did to make your double and quadruple summations faster. The most important and the most obvious is that any factor in a sum that doesn't depend on the summation variable should be factored out. Otherwise, those binomials (and other things) get recomputed many times,. Some other tricks:

1. GAMMA(s1+h+1)/(GAMMA(s1+1)*h!) = binomial(s1+h, h), even when s1 isn't an integer.
2. All necessary binomials can be pre-computed once, via very simple recursive formulae:
   [1, seq[scan= `*`]((n+1)/k - 1, k= 1..n)] generates the sequence binomial(n,k) $ k= 0..n (i.e., the entire (n+1)^st row of Pascal's triangle). By changing the order of subtraction to 1 - (n+1)/k, we generate (-1)^k*binomial(n,k).
   [1, seq[scan= `*`](1 + s/k, k= 1..upto)] generates binomial(s+k, k) $ k= 0..upto.
3. (beta1 - 1)^h*(-1)^h = (1 - beta1)^h, and of course this is trivial to generate recursively.
4. The additions of fixed terms in the denominators can be pre-computed:
   e.g., DL:= x+y + b1*(s1+h) + b2*(s2+v).
5. The undocumented command inner(A, B) computes the inner (or "dot") product of two lists of equal length; i.e., inner(A,B) = add(A*~B) = sum(A[k]*B[k], k= 1..nops(A)).
6. The updating assignment operators +=, *=, and ++ work exactly the same as they do in the numerous other languages that have them:
   S+= a  <=>  S:= S+a
   B*= k  <=>  B:= B*k
   d++  <=>  (d+= 1) - 1, i.e., it increments d and returns the pre-incremented value,

Here is my worksheet with all my improvements and verifications that my methods give the same results as @dharr.

Download FasterQuadrupleSum.mw

You wrote:

• The combine function applies transformations which combine terms in sums,...

Unfortunately, that is just the most simplistic purpose of combine. In my mind, the primary purpose of combine is to make function arguments more complicated (such as changing func1(x) to func2(2*x)); expand does the reverse, changing 2*x to x. The 2 could be replaced by any integer.

This has always seemed intuitively clear to me, and I never use a menu to do something that can be done with a typed command. Perhaps those two things are related to each other.