restart:
A:= <x1,y1,z1>:
B:= <x2,y2,z2>:
P :=<x3, y3, z3>:
H:=A+t*(B-A):
solve( (P-H)^+ . (B-A), t ):
'H'=eval(H, t=% );

If you set Digits:=15 at the beginning of the worksheet (which is always a good idea), the integral will be finite (6.32 ...). Even TP(3, 10^(-5)) will be finite (7.59...).

Explanation. For Digits=10, if you replace in TP int with Int, you will see that TP(3, 10^(-4)) is
const * int(1/sqrt(1.0 - cos(theta)) ,  theta = 0 .. const).
So, the integral is divergent.
Here 1.0 appears due to roundoff errors; the exact value is strictly > 1. For a larger Digits ==>  1/sqrt(1+eps - cos(theta)) and the integral is convergent.

By default, verify checks syntactically the equality (without any simplification).
We can use:
verify(2*cos(phi)^2-1, cos(2*phi), simplify);
or
verify(2*cos(phi)^2-1, cos(2*phi), expand);
to obtain the desired result (true).

So, you actually want

asympt( (2 * Pi * n) ^ (1/(2*n)), n, 2);
           

(the fact that taylor also works instead of asympt is strange; it should not).

You are expecting O(ln(n)^2/n^2) instead of O(1/n^2).
This would be true in terms of the standard Landau notation  O(...).  But Maple uses a modified version where the sub-polynomial functions are ignored; e.g. in this Maple notation O(ln(n)) = O(1).

Note that MultiSeries:-asympt  uses the true Landau notation. So,

MultiSeries:-asympt( (2 * Pi * n) ^ (1/(2*n)), n, 2);
will produce the expected result.

You cannot do much about this. The automatic simplification in Maple transforms 5*(x+1)+y into 5*x+5+y.
There are some tricks (such as Kitonum's) but they work only temporarily (i.e. the next evaluation reverses the transform) or can be used only for display purposes (and not for computations). It is more convenient to accept it.

Q:=proc(k::list(nonnegint))
local P,i;
P := combinat:-cartprod([seq([seq(0..i)],i=k)]);
while not P[finished] do 
  print( add(i, i = P[nextvalue]()) ) 
end do;
end:

Q([2,3]);
                               0
                               1
                               2
                               3
                               1
                               2
                               3
                               4
                               2
                               3
                               4
                               5

In more recent versions it is better to use Iterator:-CartesianProduct

P:=proc(k::list(nonnegint))
local M,i,v;
M := Iterator:-CartesianProduct(seq([seq(0..i)],i=k);
for v in M do print(add(v[])) od
end;

The integrand has the form

F := a*exp(b*v^2)*v^c;
So,
int(F, v) :  simplify(%);

i.e. it can be expressed via incomplete GAMMA ( = the  2-arguments GAMMA).

If you select that line and convert it to 1D Math input (even if it appears to be 1D), the asterisk will be visible.

Why don't you use worksheet mode with 1D input?

L1 := [{3,5},{4,3},{4,6},{3,2},{2,6}]:
L2 := [1,5,4]:
evalb( `union`(L1[]) intersect {L2[]} <> {} );

    true

Download pde!!!.mw

I'd use

A:=[x1,x2,x3]:
B:=[f(x),g(x)]:
[seq([seq(eval(b,x=a),a=A)],b=B)];

        [[f(x1), f(x2), f(x3)], [g(x1), g(x2), g(x3)]]

The command  Get('xxx1')   returns a string, but you need an exprseq. Use parse(Get('xxx1')).
Or, simply add the line
xxx := parse(xxx);  o := parse(o);  co := parse(co);

These are mathematical conventions. For degree(0) alternative conventions are -1  and "undefined".
- infinity is preferable because e.g. the equality  degree(f*g) = degree(f) + degree(g)  remains valid.
These conventions are related (and compatible) with other two standard ones:
max({}) = - infinity  and  min({}) = infinity.

Try the old-fashioned solution:

f:=x->x^2:
printf("a=?");
a:=parse(readline());
'f(a)'=f(a);