ColumnRelations:= proc(M::Matrix, {free::symbol:= :-_v})
uses LA= LinearAlgebra;
local k;
     evalc(map2(`.`, <seq(free[k], k= 1..op([1,2], M))>, LA:-NullSpace(M))) =~ 0
end proc:

ColumnRelations(M, free= v);

If the output in your worksheet can be regenerated quickly, then you should remove the output before saving it. You can use the menu selection Edit -> Remove output -> From worksheet.

Yes, you should consider dividing your worksheet. When the GUI gets bogged down, as often happens with lengthy output, there's no equivalent of the Stop button that will stop it. I've often had to kill the GUI, which kills the whole Maple process.

The worksheet below has the complete answers to your three questions, using a slightly different technique than Kitonum (very slightly different). I only post it because I was composing it at the same time that he was composing his.

Download zero-one_system.mw

Assuming that the input is floating point, the command that you want is frem(..., evalf(2*Pi)). If your input contains symbolic Pi that you'd like to keep in the output, let me know.

Here's a procedure that does what you want:

YourProc:= proc(
     fx::algebraic,
     `x= a..b`::And(name=range(realcons), satisfies(r-> op([2,1], r) < op([2,2], r))),
     n::posint,
     {functionoptions::list({symbol, name= anything}):= []},
     {pointoptions::list({symbol, name= anything}):= []}
)
local
     x:= op(1, `x= a..b`),
     a:= op([2,1], `x= a..b`),
     r:= op([2,2], `x= a..b`) - a,   #b-a
     Df:= unapply(diff(fx, x), x),
     k,   #index
     xs:= [seq(a+k*r/n, k= 0..n)]
;
     plots:-display(
          plot(fx, `x= a..b`, functionoptions[]),
          plot([seq([k, Df(k)], k= xs)], style= point, pointoptions[]),
          _rest
     )
end proc:

And an example of its use:

YourProc(
     x^2, x= -2..2, 5,
     functionoptions= [color= green],
     pointoptions= [symbol= cross, symbolsize= 24],
     axes= boxed
);

The last three arguments are optional. You could just as well use it as

YourProc(x^2, x= -2..2, 5);

Note that intervals in Maple are specified as 2..5 rather than [2,5]. However, if you insist on using [a,b], I can easily change the procedure to accomodate that.

As a workaround, you can use Maple Input (aka 1D input).

The direct cause of your problem is that you're not allowed to assign to a parameter, in this case M. You can make a local copy of M like this:

M1:= copy(M);

Then make all assignments to M1 and return M1.

There are also a few places where you used = that should've been :=.

You should begin your procedure with 

uses LinearAlgebra;

or

uses LA= LinearAlgebra;

Don't rely on the with statement being active in your procedure---sometimes it may be, sometimes it may not be.

Suppose that your dsolve result is assigned to ans:

ans:= dsolve(...);

Then do

u:= unapply(eval(u(t), ans), t);

If g=0, then f can be arbitrary and the jacobian will still be zero. That's why the fourth solution shows f unchanged.

plot3d([r, theta, Pi/6], theta= 0..2*Pi, r= 0..1, coords= spherical);

Acer's Answer is very complete. Here's a quick-and-dirty version that works in any Maple GUI. Define two procedures to be used as binary operators:

`&<`:= (a,b)-> a*exp(I*b*Pi/180):

`&+`:= proc(a,b)
local x,y;
     (x,y):= op(evalf(polar(a+b)));
     '`&<`'(x, evalf(y*180/Pi))
end proc:

Now,

(5 &< 30) &+ (4 &< 60);

Your matrix is only Hermitian if all the variables are real. If you do substitute real values for the variables, then the imaginary parts of those two eigenvalues will be zero. Is it possible to prove, in general, that those imaginary parts are real (other than by saying that the eigenvalues came from a Hermitian matrix)? I doubt it. It's well known that there are real algebraic numbers that can't be expressed in radical form without using imaginary numbers. For example, consider the roots of x^3 - 3*x + 1.

In the worksheet below, I approximate your infinite sum using an asymptotic series for BesselJ. I just did the sum itself; I ignored the constant multipliers that you have in front of the sum.

I'm not totally confident of the mathematical validity of what I did. In particular, I have some skepticism about simplifying an asymptotic series under the assumption that the variable is integer. Hopefully, someone else can comment.

P.S.: Independent computation in later Replies confirms the accuracy of this approach, although it turns out that there's a much easier way.

Download Bessel_infinite_sum.mw

In Maple, Pi is with a capital P.

I can't conceive of any message-encoding application where you wouldn't want the same number of bits in each byte. You can get the same number with the bits option to Split:

message:= `67A`:
bitP:= Bits:-Split~(convert(message, bytes), bits= 8);

Then the total number of bits is simply

8*nops(bitP);

     24

If you insist on using a variable number of bits per byte, the total number of bits can be counted as

bitP:= Bits:-Split~(convert(message, bytes));

`+`(nops~(bitP)[]);

19