1. Conversion to  Matrix  can be easier (see the code below).

2. I agree that this piece "A particular solution of the system can be then written in the form   F(t) = S(t) C0 + P(t)  where  C0 is  n by 1 and  F(0) = C0 + P(0)." of Help is incorrect.

3. The constants  C1  and  C2  for the particular solution with the specified initial conditions  x0  can be obtained as follows (first we find the general solution  x ):

restart;
A:=Matrix(2, 2, [1, 4, 5, 1]);
x0:=Vector([2,1]); #initial condition
sol := DETools:-matrixDE(A, t);
M:=convert(sol[1], Matrix);  #convert to Matrix
x:=M.<C1,C2>;  # C1 and C2 are arbitrary constants
solve(eval(convert(x=~x0,list),t=0), [C1,C2])[];
simplify(eval(x, [%[],t=0])); # The check

dice := proc()
    local r;
    r:=rand(1..6);
    'r'()$2;
end proc:

Example of use:
seq([dice()], i=1..10);
             [6, 5], [3, 1], [5, 2], [3, 2], [2, 4], [3, 3], [1, 2], [5, 4], [5, 6], [2, 3]

The code below finds 2 chains:

chosen1 := [[1,2],[1,20],[3,4]]:
chosen2 := [[2,3],[20,3],[3,4]]:
chosen3 := [[3,4],[5,7]]:
chosen4 := [[4,5],[5,6]]:
chosen5 := [[5,6],[7,9]]:
seq(seq(seq(seq(seq(`if`(i[2]=j[1] and j[2]=k[1] and k[2]=l[1] and l[2]=m[1], [i,j,k,l,m], NULL), m=chosen5), l=chosen4), k=chosen3), j=chosen2), i= chosen1);
                       [[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]],  [[1, 20], [20, 3], [3, 4], [4, 5], [5, 6]]
 

Addition.  If there are many source lists, then the process of building nested sequences can be automated using the procedure  NestedSeq  that can be found in this thread.

because

evalc(cos(I*x));  # This assumes that x is real
convert(%, exp);
                                                cosh(x)
                                     (1/2)*exp(x)+(1/2)*exp(-x)

Use  extrema  command for this (gives min and max). Optimization:-Minimize  command gives the same result.

An example:

Download min.mw

See help on  CurveFitting:-PolynomialInterpolation  command.

A:=[[1,2],[5,7]]:
B:=[[1,2]]:
(convert(A,set) intersect convert(B,set))[];

# or

A:=[[1,2],[5,7]]:
B:=[[1,2]]:
({A[]} intersect {B[]})[];
 

p := [[[0, 5], [3, 10], [1, 20], [0, 50]], [[2, 5], [0, 10], [2, 20], [0, 50]]];
evalindets(p, list(numeric), i->`if`(i[1]<>0,i,NULL)) ;

evalc  command tries to bring the result to the form  a+b*I  , in which  a  and  b  are  reals.

evalc(I^I);
evalc(2^(2*I+6));

Apparently it should be regarded as a bug in Maple. Use  is  command instead:

is(a * conjugate(a) = abs(a) ^ 2);
                                                            true

Of course, Maple knows this identity, making a corresponding simplification:

simplify(a*conjugate(a));
                                                          abs(a)^2

Here is the corrected version:

Download proc.description_new.mw

f:=(x^2+y^2+2*y)^2-4*(x^2+y^2):
plots:-implicitplot(f, x=-4..4,y=-4..4, gridrefine=3);

# Or
algcurves:-plot_real_curve(f, x, y);

# Or (in polar coordinates)
simplify(subs([x=r*cos(phi),y=r*sin(phi)], f));
solve(%, r);
plot(%[4], phi=0..2*Pi, coords=polar);
 

restart;
Set:={R = 7.339698158, S = 2.378491488, W = 2.512047349}:
X:=eval(R, Set);
Y:=eval(S, Set);  #  and so on

You can do this in one line (multiple assignment):
restart;
Set:={R = 7.339698158, S = 2.378491488, W = 2.512047349}:
X, Y:=eval([R, S], Set)[];
 

Edit.

I think that in one answer it is easy to answer for everyone:

1. Student:-Calculus1:-LimitTutor command is very weak and just fails with this example.

2. For a student studying the theory of limits, it would be more useful to solve this example manually, first getting rid of the signs of the modules in the neighborhood of point  x=2  on the left and on the right.

3. The process of getting rid of modules is easy to automate with the help of Maple, after which the task becomes quite obvious:

Expr:=(2*abs(x-2)+abs(x+1)-3)/(abs(x^2-4)+x-2);  
A:=simplify(Expr) assuming x<2 and x>1.9;  # On the left
B:=simplify(Expr) assuming x>2 and x<2.1;  # On the right
plot(Expr, x=1..3, view=0..1, discont, size=[600,300]);  # A visualization
                        

restart;
SplitChange := proc(str::string) 
local start, i, len, k, L;  
start := 1; len := length(str); k:=0;
for i from 2 to len do 
if str[i] <> str[start] then k:=k+1; L[k]:=str[start .. i-1]; start := i end if;
end do;
L[k+1]:=str[start..len]; 
convert(L, list);
end proc:

Example of use:
SplitChange("WPKCPYWYYYXHYY");
                ["W", "P", "K", "C", "P", "Y", "W", "YYY", "X", "H", "YY"]

Edit.