Just change your command from x=0 to h=0:

taylor(y(x+h), h=0);

To have matrix and vector computations done in single precision, create the Matrices and Vectors with the option datatype= float[4].

Example:

V:= Vector(1000, n-> 1/n^3, datatype= float[4]);
V.V;

                     1.01734306201200031

Compare with the result obtained using datatype= float[8], which is double precision.

                     1.01734306198444679

Note that the results begin to differ at the 9th decimal place.

You're right. I don't think that there's any way to get it to accept infinity. Here's a workaround: Use gamma instead of infinity. When the tutor is done, give the command:

limit(subs(gamma= x, %), x= infinity);

For example,

count:= 0:
for i from 1 to 9 do
     for j from 1 to i do
          count:= count+1
     end do
end do;
count;
                                              45

Of course, this example is trivial, and there are much more efficient ways to perform this particular computation.

interface(showassumed= 0):
assume(nu::real, m>0, k>0, T>0):
Int(nu*4*Pi*(m/2/Pi/k/T)^(3/2)*nu^2*exp(-m*nu^2/2/k/T), nu= 0..infinity);

value(%);

Whenever a symbol is redefined by a package, the original value of the symbol can be accessed by prefixing the symbol with :-. So in this case you'd use :-``.

with(Physics):
``(3)*``(2);
Error, (in GetDifferentiationVariables) differentiation variables for dAlembertian, d_ and D_ are not defined; either use Setup(differentiationvariables =  ...) to set them, or indicate the differentiation variables as a second argument to dAlembertian

:-``(3)*:-``(2);
                            (3) (2)

There is a policy stated in the 6th paragraph at ?name : 

Names that start with an underscore (with the exception of _Env) are used as global variable names by Maple and are effectively reserved for use by library code. Do not use a symbol beginning with an underscore. The empty name `` must never be assigned a value.

It seems that Physics violates this.

For the constraints to DirectSearch, you could generate all pairs of the variables like this:

map(`<>`@op, combinat:-choose({a,b,c,d}, 2));

You can use VolumeOfRevolution and exchange the roles of x and y:

Student:-Calculus1:-VolumeOfRevolution(
      2*t^3-t^4, t= 0..2,
      axis= vertical, distancefromaxis = -2,
      output= plot, labels= [y,x,z], caption= ``
);

I believe that this is the same surface as Preben plotted.

Is that what you were expecting?

You need to remove the definition of POWER.

restart:
ee:=u^2+v^2-w^2:
applyrule(a::algebraic^b::nonunit(algebraic) = POWER(a,b), ee);

            POWER(u, 2) + POWER(v, 2) - POWER(w, 2)

Note also the presence of the modifier nonunit. This is necessary to prevent an infinite loop (where it treats everything as itself to the power 1).

Another way:

subsindets(ee, `^`, x-> POWER(op(x)));

Download diff.mw

You simply need to use the two-argument eval command.

Download eval.mw

Assuming that you mean p is the conjugate of z, then

restart:
eq:= (2*z-3)*(-3*p+4) - (2*p-3)*(-3*z+4)=0:
solve(eval(eq, [z= x + I*y, p= x - I*y]));

Therefore z can be any real number.

Several pointers in general:

1. "e" means nothing on input to Maple.The correct name is exp. You had e in one place and exp in another.
2. Functions should be defined as f:= (x,y)-> ..., not as f(x,y):= ....
3. If you want numeric integration, use Int, not int. The latter will try symbolic integration first, potentially taking a long time.

Specifically for this problem: I got 6 digits of precision on the integral in mere seconds by passing the optional argument digits= 6 to Int. There seems to be a threshold effect: At 7 digits, it starts to take a very long time. Since you have constants in your problem with only 4 digits, 6 should be enough.

Here's your worksheet with my corrections:

Download 6_digits.mw

It's tricky because Maple automatically distributes integer factors over sums. You can do this:

Notice the special quote marks in my command. It's two single backquotes (the key under ESC on my keyboard) together with nothing in between them.

The expand command will put this back to its original form.

Download primpart.mw

By starting from the closed-form expression for the Fibonacci numbers, we can generate a one-line algebraic expression for "next Fibonacci".

Download next_fibonacci.mw