fsolve needs a bit of help here. I'm not sure why; it may be a precision issue. I didn't investigate because the workaround was obvious to me. Define A = exp(-2*a). This gives the following system of three equations, which fsolve solves immediately:

fsolve({c*A^4+18 = 36, c*A+18 = 55, A= exp(-2*a)}, {A, a, c});
             {A = 0.7864846673, a = 0.1200910258, c = 47.04478236}

Do

Sinus:= evalf@Units:-Standard:-sin:

Then compare:

Sinus(30*Unit(degree));
Sinus(30); #30 radians

Maple is a "symbolic computation system", so those string manipulations are totally unnecessary; just use subs instead.

Your equation can be easily solved with all variables symbolic and using a logarithm to an arbitrary base, B:

restart:
equation1:= filler(a*x+b) - filler(c*x+d) = rs:
equationAct:= subs(filler= log[B], equation1):
simplify(solve(equationAct, x));
             (b - B^rs*d)/(c*B^rs - a)

The condition for both log arguments to be positive is (b*c - a*d)/(c*B^rs - a) > 0.

If you ever again get the urge to use string manipulations to do math, ask here for an easier way.

Your procedure has highly symbolic components such as isolate; it could never beat pure integer arithmetic.

Here's my version of repeated squaring. It's like VV's except that I unrolled his recursion into a do loop. It works for any associative operator (such as square matrix multiplication or modular multiplication), with the default being ordinary `*` multiplication.

RepSq:= proc(X, N::nonnegint, `*`:= :-`*`, Identity:= 1)
local x:= X, R:= Identity, n:= N;   
     do
          if n::odd then R:= `*`(x,R); n:= n-1 fi;
          if n=0 then return R else n:= n/2 fi;
          x:= `*`(x,x)
     od
end proc
: 

Some pointers on algorithm timing, referring to mistakes that you made in yours:

1. Don't display output and make a timing at the same time. Suppress the output and display it later if it's needed. For example, note that the number needs to be converted to base 10 to be displayed, and you don't want to be timing that.

2. You need much, much larger examples and many, many more of them to get meaningful timings. It's inconceivable that your puny numbers took 0.04 seconds to exponentiate; all you're measuring is overhead. Try a list of a thousand numbers with exponents in the hundreds of thousands. (Make absolutely sure that you suppress the output in this case!! When the GUI gets its output buffer overloaded, there's nothing that you can do except either wait hours for the output to display or kill the GUI (which unfortunately kills all your open worksheets).)

3. CPU time is a more meaningful comparison than real time for raw algorithms, such as this. Real time is more meaningful for comparing parallelized code or code that does disk I/O operations.

No Maple assumptions are needed for this:

ysol:= piecewise(x < 1/2, 2, x >= 1/2, 0); #1/2, NOT 0.5
​​​​​​diff(ysol, x);

In Maple, you should never use a decimal number such as 0.5 as an abbreviation for an exact fraction such as 1/2. 

Your code had some minor syntax errors, as corrected by Tom. Your algorithm (as opposed to your code) has two major flaws (not errors): It uses matrix inversion, and it unnecessarily recomputes the symbolic Jacobian on each iteration. Here is my rewrite that avoids those things. Inversion is replaced with solving a linear system, and the Jacobian is computed once before the loop. I also added argument-error checking and made TOL and itmax optional with default values. The solution is returned if convergence (as measured by TOL) is achieved; otherwise an error message is given.

Download Newton.mw

The ​​​​​​solve command, used by Rouben, says that's there's no unconditional or "free" solutions, which is not suprising given that there are 12 equations for 6 unknowns. The eliminate command is an alternative that gives conditions under which solutions exist. I think that there's a good chance that that's what you're interested in. The following worksheet is meant to be put at the end of Rouben's. 
 

Download Conditional.mw

Numerous applications, particularly in number theory, require only the integer part of the base-2 logarithm. There is a special command for that, ilog2(6), which is much more efficient than floor(log[2](6)).

This is done with the identity option to solve.

solve(
   identity(
      cos(t)^6+a*cos(t)^4*sin(t)^2+b*cos(t)^2*sin(t)^4+c*sin(t)^6 = cos(6*t), 
      t
   ), 
   {a,b,c}
);
                   {a = -15, b = 15, c = -1}

These very small imaginary parts are due to round-off error in float computations. I call them spurious imaginary parts, because the true answers are real. They can be removed by

simplify(fnormal([%]), zero);

In some exceptional cases, you may need to specify a tolerance (a number of digits) as a second argument to fnormal. See help page ?fnormal.

The RealDomain package is not appropriate for this. It's better to generate the answers with the imaginary parts and then remove them than it is to try to generate them without the imaginary parts.

The command to turn an expression into a function is unapply.

Mat:= module()
option package;
uses CF= CurveFitting;
export 
     LinModel:= proc(xliste::list, yliste::list, $)
     local a, b, x;
          unapply(
               CF:-LeastSquares(xliste, yliste, x, 'curve'= a*x+b),
               x
          )
     end proc; # LinModel 
end module; #Mat

If you are returning a function, there's no need to pass x to LinModel. Thus, I've made it a local.

What you've called sys is already a set because you put it in braces; then you've put that and the initial condition into more braces. So, your first argument to dsolve isn't a set of equations; rather, it's a set that contains an equation and also contains a set of equations. So, you can make your dsolve command

dsolve({sys[], varphi(0) = 0});

The [] after sys extracts the elements of the set sys. I do not understand why you include the arguments Xa, Xb, Ya, Yb in the command.  

Substitute exact fractions such as beta = 3/10 rather than decimals such as 0.3. If you use a decimal before calling dsolve, it will automatically change it to an exact fraction, which is why your (4) is correct. 

L:= [a,b]:
`/`(L[]);
             a/b

If for some strange reason you want your convert command to work, do

`convert//`:= (L::list)-> `/`(L[]):

Now,
convert([a,b], `/`);
             a/b
works. I say "strange" reason because the first way shown seems so much easier than using convert. But in general, to make convert(..., foo) work, define a procedure named `convert/foo`; or if you're curious how a stock command such as convert(..., list) works, then look at showstat(`convert/list`).

It'll be a lot easier to display summation notation than "..." form, so how about

Sum(q[i], i= 1..n);

?