You should take a look at Maple 2021 where the Student:-ODEs package was introduced. And it was expanded in subsequent versions. Please see the update documentation on our website for more details.

In Maple 2016, there is nothing equivalent, I'm afraid. You can set infolevel[dsolve]:=1 (or a higher integer, up to 5) before calling dsolve, but the output is for diagnostic purposes, not for education.

In 2D Math Input mode, you can enter the z and then navigate to "overscript" (see 2DMathShortcutKeys for the help page) and click on the Overbar symbol in the Fenced palette (which may not be visible by factory default; see "View > Palettes > Show Palette" then).

This will be interpreted as conjugate(z).

There is no code translator, but please see the very last paragraph of this overview document: Maple 2023 Coding Tools

So you can edit and execute Python code directly in Maple 2023. The interpreter built into Maple has been around for some time now, but the enhanced editor makes it easier to use this language.

Please see the last sentence of the description of the output option: If a string is given as the value, then the output is appended to a file having that name.

I guess the chances of getting useful answers will be higher if you post your input in valid Maple syntax. Uploading a worksheet may not be necessary then.

First of all, use parentheses for grouping terms in an expression. Square brackets are for constructing lists and indices.

Next, the int command requires specifying the integration variable (presumably x in your input).

That's not possible. Executing a Maplet requires Maple. But you can launch the Maplet Viewer (e.g. mapletviewer.exe under Windows) so that no Maple worksheet interface is opened.

If you can rewrite your Maplet so as to use Embedded Components (using the DocumentTools package), the worksheet will be usable in the free Maple Player. This is the recommended way to go.

You just need to replace Accumulate by add, and Log2 by log2:

A219954list := nmax -> local n; add([seq(ifelse(n = 1, 0, 3^numboccur(convert(n - 1, 'base', 2), 1) - ifelse(type(log2(n), integer), 1/2*n, 0)), n = 1 .. nmax)]);

seq(A219954list(n),n=1..33); 

Whether that's all correct and/or efficient, I did not check (it's my lunch break, sorry).

Input errors aside, the best command for this task is pdetest. It works really straightforward:

pdetest(solution, pde);

where solution is (typically) the output of pdsolve. No need to hassle with subs, eval and simplify.

For input display, I don't think that's possible in Maple Flow.

Correction: try command completion right after entering diff (i.e. press Ctrl+Space on Windows, or Cmd+Shift+Space on macOS), and select partial d operator.

For output display, just enter diff(u(x,y,z),x,x) (likewise for the other derivatives), or - for the Laplace equation:

VectorCalculus:-Laplacian(u(x, y, z), coords = [x, y, z]) = 0

Help > Maple Help > How Do I... (2nd bullet item under Resources) > ...solve an ordinary differential equation?

Simply add this line:

plot(rhs(solution), t = 0 .. 5);

Your worksheet was saved with Maple 18 which is quite old.

The problem was fixed in a later version - not sure when exactly, but Maple 2023 gets it right. So the recommendation is to upgrade.

The following will return two formal solutions for nu, but I doubt they will be of much use:

Note that I have cleaned up parentheses a bit, and replaced U[w] by U__w (literal subscript, as opposed to indexing).

eta := (x,y,t) -> y/((nu*t*cos(alpha)+nu*x/U__w*sin(alpha))^(1/2));
psi := (x,y,t) -> U__w*(nu*t*cos(alpha)+nu*x/U__w*sin(alpha))^(1/2)*f(eta(x,y,t));

transf := [u(x,y,t) = diff(psi(x,y,t),y), v(x,y,t) = -diff(psi(x,y,t),x)];

eq1 := diff(u(x,y,t),x) + diff(v(x,y,t),y) = 0;
eq2 := diff(u(x,y,t),t) + u(x,y,t)*diff(u(x,y,t),x) + v(x,y,t)*diff(u(x,y,t),y) - nu*diff(u(x,y,t),y,y) = 0;
sys := [eq1,eq2]:

newsys := eval(sys,transf);
# newsys[1] is trivial: 0=0
neweq := simplify(newsys[2]);
solve(neweq,nu);

Does this help?

Perhaps it's more useful to run pdsolve on the original system sys.

There are several ways to obtain that; I find this one quite easy:

p := x^2-a*x-b*x+a*b;
                                           2
                   p := a b - a x - b x + x 

eval(p,[a=2,b=3]);
                           2          
                          x  - 5 x + 6

L := [[2,3],[-3,7],[9,10]]:

seq(eval(p, [a,b] =~ para), para in L);
           2             2              2            
          x  - 5 x + 6, x  - 4 x - 21, x  - 19 x + 90

See the help pages on eval and the tilde (elementwise operator) for more background information.

You can query an event and optionally install your own event handler like this:

NumericStatus(real_to_complex);
sqrt(-5);
NumericStatus(real_to_complex);

MyHandler:=proc(operator,operands,default_value)
   WARNING("You must assume the sqrt argument is positive."):
   return(default_value):
end proc:

NumericEventHandler(real_to_complex=MyHandler):

sqrt(-5);

For more details, please enter ?NumericEventHandler to open the help page.

If you additionally want sqrt(-5) to return the symbol undefined (as opposed to I*sqrt(5)), just load the RealDomain package. It is not perfect, however: it may not catch every situation where complex numbers arise.