Set new initial conditions after the singularity, and plot on the range after the singularity. Then combine the plots. For your case, I set n(14) = 1.1, T(14) = 1.1, then plotted on 14..30. It reaches the next singularity at t = 27.....

To convert a table T into a list in the order implied by its indices, use 

[entries(T, 'indexorder', 'nolist')];

instead of

convert(T, 'list');

Also, the plot and Statistics commands accept lists as well as Vectors. With these changes, your code simplifies to

restart:

Atot:= 0:
PtotFkt:= ii-> ii^2: #Keep function definition outside loop.

for ii from 0 by 0.01 to 2 do
     (Atot, A[ii], t[ii]):= (Atot + 0.01*PtotFkt(ii), Atot, ii)
end do:

#Conversion from tables to lists.
#Reuse names A and t to encourage garbage collection.
(A,t):= [entries]~([A,t], 'indexorder', 'nolist')[]:

plot(t, A, style= point, symbol= asterisk, color= blue);
regress:= Statistics:-PolynomialFit(10, A, t, time);
plot(regress, time= 0..2);

In the future, please use plaintext for your posted Maple code, or upload a worksheet. Then we won't need to retype your commands.

The solve your problem, go to the Maple Application Center and download the package DirectSearch. The worksheet below shows how to use it. You can see that the package stumbles around a bit before coming up with a solution, but the solution that it finally produces is accurate.

Download Temp_Power.mw

Why not simply use solve:

solve((z^2-1)/(z^2+1) = c, z);

Simple: Use a local declaration:

lisse:= proc(...)
local AzIII;
...
end proc:

It's not built-in (AFAIK), but it can be written as a trivial one-liner. However, you do need to specify the maximum number of bits to allow for the numerator.

`convert/dyadic`:= (x::nonnegative, b::posint)-> ``(trunc(x))+round(2^b*frac(x))/2^b:

convert(1.74, dyadic, 5);

     (1)+3/4

convert(1.74, dyadic, 6);

     (1)+47/64

The pochhammers can be converted to summations by following the differentiation command with

convert(%, Sum);

The best simplifier that I've found for explicit algebraic numbers (meaning those specified without RootOf) is evala@evalc. In this case, this combo will quickly reduce a, b, and c to a form from which it's obvious that no further simplification is possible. Then I do two independent verifications--one numeric and one symbolic---that these simplifications are correct. The numeric is evalf[10]@evalf[999]; the symbolic is evala@Normal.

Download evala_evalc.mw

Square brackets can't be used as a higher level of parentheses. Only round parentheses may be used for algebraic grouping.

After you correct that, it'll require many function evaluations and several minutes for it to integrate out to 20. You need to include the option maxfun= 0 in the dsolve command so that it doesn't try to limit the number of function evaluations.

I doubt that in the general case that it's possible to do any better than this brute force method:

Ker:= (H, g1::Group)->  select(g-> H(g)=Perm([]), GroupTheory:-Elements(g1));

where H is the homomorphism. Certainly nothing to this end is already implemented in Maple 18.

As far as I'm concerned, the correct way to do it is now, and always (at least since Maple Vr4) has been, 

t:= (a/b)^2*x*y:
fprintf(outfile, "%A:= %A;\n", 't', t);

Your usage of cat doesn't seem to be supported by the documentation at ?cat, which clearly states (in Maple 18) that cat may return an object of type `||`. Also, it's been ages since strings and names were considered the same thing. You're using names; you'd be better off using true strings.

The Algebraic package is simply not designed to work with floats. If you want to use floats, then either preprocess your expressions with convert(..., rational), or use package SNAP.

I think that nextprime is easier to use for this purpose than ithprime.

Here's a program. In order to not do your homework for you, I left two blanks (represented by ...) for you to fill in.

FirstCompositeRun:= proc(n::posint)
(* Returns the smallest positive integer that starts a
     sequence of n consecutive composites. *)
local p1:= 2, p2:= ...;
     while p2 - p1 <= n do
          ...;
          p2:= nextprime(p2)
     end do;
     p1+1 #Return value
end proc:

Its use:

FirstCompositeRun(100);

     370262

A proper Maple program should almost never use print to return its value because

• it makes it nearly impossible to communicate the result with other programs,
• it forces the end user to see results that they don't necessarily want to see,
• it's the hallmark of a rank beginner who's learned bad habits from using other languages.

A good place to start is ?Student,Calculus1,VolumeOfRevolutionTutor.

assume(n, positive);
E:= 3^(-(1/2)*n)*2^((1/6)*n)-2^((2/3)*n)*6^(-(1/2)*n):
combine(simplify(convert(E, exp), radical));

     0