Yes, it is easy to use a color gradient in a 2D point plot. In the following, assume that

• XY is a list of pairs of (x,y)-values (each pair itself being a list), 
• f is a function of two variables that returns your f-value for any point as a floating-point number (force it to floating point with evalf if you need to),
• Mf is the maximum value of f,
• mf is the minimum value of f.

Then do

R:= Mf - mf:
plot(`[]`~(XY), style= point, color= [seq(COLOR(HUE, (f(xy[]) - mf)/R), xy= XY)]);

For example, here I take 2^12 random points in [-9,9] x [-9,9] and color them based on the sine of the x-coordinate:

XY:= RandomTools:-Generate(list(list(float(range= -9..9), 2), 2^12)):
plot(`[]`~(XY), style= point, color= [seq(COLOR(HUE, (1+sin(xy[1]))/2), xy= XY)]);

 It is also possible to do a gradient between any two given colors.

Here is the command to create the graph, where A and B are the vertices of degree 2 that I added.

K:= GraphTheory:-Graph({{1,A},{1,2},{1,4},{1,B},{2,3},{3,4},{2,A},{4,B}, {1,3}}):

Now you can work with the graph object K using other commands in the GraphTheory package. For example, you can display it:

GraphTheory:-DrawGraph(K, style= planar);

You can't (safely) use implied multiplication, and you need parentheses for all function calls. So, you need to change your definition of r to

r:= t-> <4*cos(2*t)+4*sin(t), 5*cos(3*t)+4*cos(t),(sin(3*t)+2*sin(t))^2>;

Then your spacecurve command will work.

I have a vague feeling that I may be missing something important in this discussion (especially since I would've expected Acer to come up with this also), but doesn't the following simple code, which uses no unapply and no quotes, do what you want?

G:= [seq(subs(_u= u, theta-> x-> _u*theta*x), u in [v1,v2])];

Many commands (perhaps most) don't automatically map themselves over container objects such as Vectors, lists, and sets. This can often be achieved by appending ~ to the command name, making it into an elementwise command. In your case, this works:

A:= Vector([1, 2, 3]):
solve~(2*A =~ 5+x);

Note also the use of the ~ in =~. See ?elementwise.

If you're willing to change Matrix A itself, you can perform the operation in place, which saves time, memory, and typing:

A[.., 1]:= b;

Matrix, in addition to being a type, is also a procedure. It's the constructor procedure for matrices that you just used. When you use print, it forces the expansion of the name Matrix into its underlying procedure. You'd get the same thing if you'd executed print(Matrix) at the top level (i.e., outside a procedure). The solution to your problem is to simply not use print. A procedure's return value is simply the result of its last executed statement; there's no need to use print to see a procedure's result. Indeed, it is a bad practice to use print in this way. It should only be used to display supplementary information, not the procedure's return value.

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