You can restrict T  using assumptions.

plot([Re(sqrt(sin(x))), Im(sqrt(sin(x)))], x = 0 .. 4*Pi, legend = [typeset("Curve: ", Re(sqrt(sin(x)))), typeset("Curve: ", Im(sqrt(sin(x))))]);

for: 0 < T < Pi

simplify(int(sqrt(sin(x)), x = 0 .. T)) assuming 0 < T < Pi

#-sqrt(2)*(EllipticF(sqrt(2)*sqrt(sin(T))/sqrt(sin(T)+1), (1/2)*sqrt(2))-EllipticPi(sqrt(2)*sqrt(sin(T))/sqrt(sin(T)+1), 1/2, (1/2)*sqrt(2)))

and for: Pi < T < 2*Pi

simplify(int(sqrt(sin(x)), x = 0 .. T)) assuming Pi < T < 2*Pi

#sqrt(2)*(I*EllipticF(2*sqrt(sin((1/2)*T))*sqrt(-cos((1/2)*T))/(cos((1/2)*T)-sin((1/2)*T)), (1/2)*sqrt(2))-I*EllipticPi(2*sqrt(sin((1/2)*T))*sqrt(-cos((1/2)*T))/(cos((1/2)*T)-sin((1/2)*T)), 1/2, (1/2)*sqrt(2))+4*EllipticE((1/2)*sqrt(2))-2*EllipticK((1/2)*sqrt(2)))

EDITED:

Generally my method works if Maple does not have errors(Bugs).

Workaround:

f := proc (T) options operator, arrow; int(sqrt(sin(x)), x = 0 .. T) end proc;
[f((1/4)*Pi), f((1/2)*Pi), f(3*Pi*(1/4)), f(Pi)];

#[-sqrt(2)*EllipticF(sqrt(2)*sqrt(sqrt(2)/(2+sqrt(2))), (1/2)*sqrt(2))+sqrt(2)*EllipticPi(sqrt(2)*sqrt(sqrt(2)/(2+sqrt(2))), 1/2, (1/2)*sqrt(2)), -sqrt(2)*EllipticK((1/2)*sqrt(2))+2*sqrt(2)*EllipticE((1/2)*sqrt(2)), -sqrt(2)*EllipticK((1/2)*sqrt(2))+2*sqrt(2)*EllipticE((1/2)*sqrt(2))-sqrt(2)*EllipticF(cos(3*Pi*(1/8))*sqrt(2), (1/2)*sqrt(2))+2*sqrt(2)*EllipticE(cos(3*Pi*(1/8))*sqrt(2), (1/2)*sqrt(2)), -2*sqrt(2)*EllipticK((1/2)*sqrt(2))+4*sqrt(2)*EllipticE((1/2)*sqrt(2))]

Regards,MI

Well Maple is very weak for solving symbolic sum and can't solve your example.

`assuming`([sum((d*k+a)^r, k = 1 .. n)], [n::posint, r::posint, r > 0, a > 0, d > 0]);

# returns unevaluated

Mathematica 11.2 solution:

Translated code form MMA to Maple:

Sum((d*k+a)^r, k = 1 .. n) = d^r*(Zeta(0, -r, (a+d)/d)-Zeta(0, -r, (d*n+a+d)/d));

Regards,MI

sol:=identify(evalf(2*ln(3)-3*ln(2)));

# arcsinh(17/144)

simplify(convert(sol, arccoth), symbolic);

# 2*arctanh(1/17)

Only for inverse hyperbolic function.

with(gfun);
l := [8, 32, 128, 512, 2048];
rec := listtorec(l, u(n), [ogf]);

# rec := [{u(1+n)-4*u(n), u(0) = 8}, ogf]

You must only change to:  u(1) = 8

sol:=rsolve({u(1+n)-4*u(n), u(1) = 8}, u(n));

#Answer is: 2*4^n
#or:
sol:=rsolve({eval(op([1, 2], rec), 0 = 1), op([1, 1], rec) = 0}, u(n))

[seq(sol, n = 1 .. 6)]; #Check:

#[8, 32, 128, 512, 2048, 8192]

I don't know how to change: 2*4^n = 2*2^(2 n) = 2^(2n+1) in Maple!

simplify(2*4^n, power);# Dosen't work!

For first example:

restart: 
Digits := 30:
convert((k-2)*(k^2+5)*(k^3-k^2+7*k+8)/(6*k*(k^2-3*k+8)), parfrac, k);

and factor expression k^2-3k+8  by:

(1/6)*k^3+k-1/2-5/(3*k)+convert((-3*k-6)/identify(factor(denom(op(4, sol)), complex)), parfrac, k);

 and last 2 expression:

identify(factor(k^3+3*k^2+11*k-3, complex));
identify(factor(k^2+2*k+9, complex))

f := proc (x, z) options operator, arrow; ln(x^z) end proc;
simplify(f(x, 2), symbolic);
collect(expand(simplify(f(x, 1/2+I*y), symbolic)), ln(x));

Note: When the symbolic option is specified, any branch of a multi-valued function can be chosen during the simplification process. The result of such an operation is in general not valid over the whole complex plane and can lead to incorrect results if you assume the expressions represent analytical functions.
 

eq16 := r(t) = d[vol]*V/(KUS*V^2+L*tau);
ex := InertForm:-MakeInert(convert(rhs(eq16), fullparfrac, KUS)):
eq17 := r(t) = op(1, ex)/expand(simplify(op(2, ex)));

restart:
with(Physics[Vectors]):
Setup(mathematicalnotation = true):
eq := r(t) = 2*t^2*_i+16*_j+(10*t-12)*_k;
v := diff(rhs(eq), t);
V := eval(v, t = 10);
simplify(Norm(V));

restart;
with(Physics[Vectors]);
Setup(mathematicalnotation = true);
eq := r(t) = 3*cos(5*t)*_i+sin(5*t)*_j+3*sin(5*t)*_k;
Norm(rhs(eq));#Calculate Norm
plots:-spacecurve([Component(rhs(eq), 1), Component(rhs(eq), 2), Component(rhs(eq), 3)], t = 0 .. 4*Pi, color = pink);

Have fun!

restart;
q1 := 9045.084972*(diff(z[1](t), t$2))+863728.7570*z[1](t) = -1963.525491562420*sin(20*t);
q2 := 3454.915028*(diff(z[2](t), t$2))+2.261271243*10^6*z[2](t) = -286.4745084375789*sin(20*t); icy := seq([z[i](0) = 0, (D(z[i]))(0) = 0], i = 1 .. 2, 1);

so := dsolve({q1, q2, seq(icy[i][], i = 1 .. 2), A(t) = diff(z[1](t), t$2), B(t) = diff(z[2](t), t$2)}, numeric); so(1);

plots:-odeplot(so, [[t, A(t)], [t, B(t)]], t = 0 .. 1, color = [red, blue], legend = ["diff(z[1](t), t$2)", "diff(z[2](t), t$2)"], legendstyle = [font = [times, bold, 20]]);

Have fun!

w := proc (x, y) options operator, arrow; piecewise(y <= .5, -2*tanh(y-.25), .5 < y, 2*tanh(.75-y)) end proc;
Matrix([seq([seq(w(x, y), x = 0 .. 10)], y = 0 .. 10)]);

#or;

Matrix([seq([seq(w(x, y), y = 0 .. 10)], x = 0 .. 10)]);

You don't gives values of constans,so I assuming.

restart;
Digits := 20;
Theta := (1/3)*Pi; Upsilon := 1/10;#assume!
eq := ((D@@2)(u))(r) = (-(D(u))(r)^2*u(r)+((Upsilon-1)*(1/2))*(1-u(r)^2-(D(u))(r)^2)*((D(u))(r)*cot(Theta)+2*u(r)))/((D(u))(r)^2-((Upsilon-1)*(1/2))*(1-u(r)^2-(D(u))(r)^2));
sol := dsolve({eq, u(13.75) = .7787, (D(u))(13.75) = .344037}, numeric, abserr = 1.*10^(-16));
plots:-odeplot(sol, [[r, u(r)], [r, (D(u))(r)]], r = 0 .. 13.75, legend = [typeset("Curve: ", u(r)), typeset("Curve: ", (D(u))(r))]);

It's possible Bug in Ode Analyzer Assistant.

You must write equation like so:

y[1](x) -> y1(x)
y[2](x) -> y2(x)

diff(y1(x), x$2)+3*(diff(y1(x), x$1))+2*y1(x)+2*y2(x) = 3,

diff(y2(x), x$2)+diff(y2(x), x$1)+2*y2(x)+2*y1(x) = 8;

Regards Mariusz.

maybe like so:

expand(eval(pdsolve({diff(u(x, z, t), z)+C = 0, u(x, a, t) = 0}), a = h(x, t)));

#u(x, z, t) = C*h(x, t)-C*z

Maple has this function Totient(n) built-in.This command was introduced in Maple 2016. Using showstat function we can preview the code.

with(NumberTheory):
showstat(Totient);
showstat(PrimeFactors);

NumberTheory:-Totient := proc(n::{posint, And(algebraic,Not({boolean, `in`, complexcons, extended_numeric}))}, $)
local prime_factors, p;
   1   if not type(n,'posint') then
   2       return ('procname')(n)
       elif isprime(n) then
   3       return n-1
       else
   4       prime_factors := NumberTheory:-PrimeFactors(n);
   5       return n*mul(p-1,`in`(p,prime_factors))/convert(prime_factors,'`*`')
       end if
end proc

NumberTheory:-PrimeFactors := proc(n::{integer, And(algebraic,Not({boolean, `in`, complexcons, extended_numeric}))}, $)
local i;
   1   if n = 0 then
   2       error "cannot represent all prime factors of %1", n
       elif type(n,{'negint', 'posint'}) then
   3       return {seq(i[1],`in`(i,ifactors(n)[2]))}
       else
   4       return ('procname')(n)
       end if
end proc

Another code you can find on this webpage: http://oeis.org/A000010 see:MAPLE -> # version 2.

Have fun !