In the call to odeplot, change [x,U(x)] to [[x,U(x)], [x,S(x)]]. In the call to animate, change the range from -2..0 to -2..-0.1 to avoid the singularity at x=0.

If you have an existing proc procedure to which you want to give the property of being distributive over the first argument, then you can include the following statement before the main computation:

if args[1]::`+` then return map(thisproc, args) end if;

The simplest example---a procedure that does nothing other than distribute itself over its first argument---is

d:= proc(a,b)
     if args[1]::`+` then return map(thisproc, args) end if;
     'procname'(args)
end proc:

d(a+b, c);

Is r*t-m also negative? If yes, then you can solve the imaginary number problem by

combine(v(t), symbolic);

If no, then the imaginary numbers are "really" part of your problem, and you need to figure out their significance. Just making the ln "disappear" isn't an adequate solution.

The command that you tried to post as an "Inline image" didn't show up. In the future, just copy-and-paste plaintext of your command.

I'm going to guess that your command was something close to

plot(x/x, x= -1..1, discont= [showremovable]);

The reason why the hollow point doesn't appear in this case is something called automatic simplification : Certain expressions are automatically simplified before being passed. In this case, x/x is automatically simplified to 1 beforeit's passed to plot. There's nothing that you can do to prevent this.

However, if you want to test the showremovable option, the following works:

plot((x^2-x)/x, x= -1..1, discont= [showremovable]);

Change the line

MM:= Minimize(J, {seq(CC1[i]=0 and CC2[i]=0, i=1..numelems(CC1))});

to

MM:= Minimize(J, {seq([CC1[i]=0, CC2[i]=0][], i=1..numelems(CC1))});

The commands in Optimization don't accept constraints with Boolean operators, such as and.

A very often-discussed topic here on MaplePrimes is a better alternative for the awkward and slow combinat:-cartprod. 

L:= [ [ [1,2], [2,1] ], [ [3,4], [4,3] ], [ [5] ] ]:

CartProd:= proc(L::list(list))
local S, _i, V:= _i||(1..nops(L));
     [eval(subs(S= seq, foldl(S, [V], (V=~ L)[])))]
end proc:

(op~)~(CartProd(L));

Between the two inner loops you have two statements. The second of those statements needs a semicolon at its end.

Yes, there's a three-argument operator form of if: `if`. It's very similiar to the (...?...:...) operator in C. For example:

seq(`if`(k::prime, 1, 0), k= 1..10);

     0, 1, 1, 0, 1, 0, 1, 0, 0, 0

What's a little more difficult in Maple is an embedded assign-and-increment statement such as your idx+= 1. This can be implemented like this:

`&+=`:= proc(x::evaln, inc::algebraic)
     assign(x, eval(x)+inc);
     eval(x)
end proc:

idx:= 1:
seq(`if`(i > 2, idx &+= i, idx+i), i= 1..10);

    2, 3, 4, 8, 13, 19, 26, 34, 43, 53

It's fairly easy. Here's a worksheet for it.

Download permL1toL2.mw

Use the command Elements:

Elements(P2);

lprint(%);

{Perm([]), Perm([[1, 3, 5]]), Perm([[1, 5, 3]])}

Using the example that you provided, and automating the process of making the assumptions:

B:= [a-1, b+2, b-c, a*c-1]:
f:= a^2*c-a*c-a+1:
is(f <> 0) assuming (B <>~ 0)[];

     true

Unlike assume, assumptions made with assuming only last for duration of one command.

Since the x doesn't explicitly appear in g, you'd need to use

f:= unapply(piecewise(x<0, 0, x>0, g), x);

If you use the arrow form, then the x that appears in g isn't the same variable as the x to the left of the arrow: The former is a global variable, and the latter is a parameter.

This is almost certainly on a list of the top ten most-common Maple errors.

The button that you want is already there. It's the !!! in the middle of the top row of the tool bar.

The documentation about this use of % is at ?value.

The entire purpose of the command

%piecewise(``, x+y-2*z = 1, ``, 2*x+y-3*z = 5, ``, -x+y+z = 1);

is to achieve a certain prettyprinted effect: the equations in a column with a large curly brace on the left side. This was never intended to be converted from its inert form to active form. This command has no relation mathematically or computationally to the piecewise command; its only relation to piecewise is that its author wanted to display some equations in a manner similar to the way that Maple displays piecewise functions.

The name u remains---and must remain---entirely symbolic after the call to dsolve. Indeed, it is unusual (although not impossible) for any command to change the value of a name without an explicit assignment statement. If you do want a function that returns numeric evaluations of u, do this:

U:= X-> eval(u(x), num_n(X));

Now U(1) will return 1.