Yes, it's suprisingly easy:

evala(Norm(x - (2^(1/2)+2^(1/3))));

Or, equivalently,

evala(Minpoly(2^(1/2)+2^(1/3), x));

Both of these commands will accept extra arguments allowing you to specify a larger field of coefficients. The default field is the rationals, of course.

Yes, you can define your own type-conversion procedures to be used with convert, like this:

`convert/coefflist`:= (s::series)-> local k, S:= [op](s), L:= S[2]; 
    ([seq](Array(L..S[-3], {seq}(S[k+1]=S[k], k= 1..nops(S)-3, 2))), subs(0= (), L))
:

Usage:

convert(series(cos(x), x, 10), coefflist);
convert(series(x^2*sin(x), x, 10), coefflist);
convert(series(x^(-2)*sin(x), x, 10), coefflist);

In the 2nd and 3rd examples, the integer returned after the list is the lowest exponent, which is returned when it's other than 0.

The procedure makes use of the fact that array entries that aren't explicitly set are automatically 0.
 

Try this:

GainQ1:= 8*wx^2*(m-1)/(Pi^2*sqrt((m*wx^2-1)^2+Q1^2*wx^2*(wx^2-1)^2*(m-1)^2));
params:= [m= 6.3, Q1= 1];
a:= eval(GainQ1, params);
Top_of_Q1:= maximize(a, wx= 0.1..2., location);

In the procedure, replace print(eq) with 

entries(eq, 'nolist')

The print command is never an appropriate way for a procedure to return its results.

I don't think that Preben or Tom explicitly said this, so I guess that it's worth saying: In this case, assumptions on the parameters can't help. That's a mathematical fact, not a Maple limitation, because the Fundamental Theorem of Algebra tells you that there'll always be 4 solutions for w(x) that are constant with respect to x.

My general personal opinion about Maple assumptions is that they shouldn't be used (even when they're mathematically true) in cases where it's known that they can't help. This is because they occasionally prevent you from getting valid solutions, which you'll then never know about.

An easy way to select only the nonconstant solution is to include an initial condition that includes a constant of integration, like this:

dsolve({q, w(0)=C1})

Your command array should be Array. The lowercased array is a "deprecated" command, meaning that it's a long-obsolete command that shouldn't be used any more. Indeed, it was obsolete before the ExcelTools package even existed.

While that's certainly true, I don't think that it will fix your problem. It looks like Export automatically converts an array to an Array.

It looks like you're trying to learn Maple but that you have some experience with other computer languages. The code in my worksheet below may be a bit intense, but perhaps you're already aware of similar things in those other languages. Anyway, please look up what you can in Maple's help pages, and please ask any questions that you have about it. And don't spend too much time trying to understand a confusing help page; you can just ask about it here.

Given that your primary interest in your code is computing the maxes of Collatz sequences, these efficiency improvements are possible:

1. (This one is easy, and obvious): You only need to check for a new max after doing a 3*i+1 step, not after an i/2 step.
2. Memoization (this is subtle): Memoization refers to a procedure recording the results of its calls so that if called again with the same arguments, it doesn't need to redo the computation. Usually, this can be done very simply by putting option remember in the procedure's opening part. That doesn't work very well in this particular case, so my code uses an explicit table as a remember table.

Here's how the remember table works mathematically with the maxes of Collatz sequences (and this would work for any collection of finite sequences of reals sharing a common formula): Suppose that we have two positive integers a and b for which we want to compute the maxes Ma and Mb of their sequences A and B. First we compute A and Ma. We note the position K in the sequence where Ma is attained. In the table, we record that Ma is the max for all sequences beginning with A[k] for k from 1 to K.

Next we compute B and Mb. Suppose that at some point the sequence value in B is one of  those A[k] for which we've already recorded a value. Then it's obvious that Mb is the larger of Ma and the largest value computed so far in B. So, we don't need to finish sequence B! 

Obviously that process (which I just detailed for 2 sequences) can be extended to any number of sequences. If we were only doing a small number of sequences, the extra work required to do this likely wouldn't be worth it. But it is worth it if you want the maxes of a large number of sequences. Below, I do it for all odd numbers upto 1 million in under 7 seconds. Without memoization, it takes over 60 seconds.

Download Collatz.mw

In your 2nd attempt, you are missing a comma after stetsel in the solve command.

In your followup, you didn't load package LinearAlgebra​​​​​. 

The messages should be different; foo doesn't use z. The z-> assign(z) is a separate procedure for which z is a parameter, which is a quite different thing from a local variable. 

I don't know why floor is treated differently than sqrt in this regard---probably an oversight. Anyway, what you want can be done by

plots:-textplot([2,2, Typesetting:-Typeset(floor(5.5))]);

The answer is simply the Taylor series at x=1.

p:= x^4-3*x^2+3:
taylor(p, x=1, degree(p,x)+1);
 

The function that you want is the inverse function of the CDF. In Maple, it's called Statistics:-Quantile. Specifically, you want Quantile(Y, 0.05) for a 5% left tail and Quantile(Y, 0.95) for a 5% right tail.

I do not use the so-called "short-form" names for package commands--ever-- because I think that they reduce code readability (a reader unfamiliar with the packages can't see immediately which package (if any) a command comes from). Instead, at the top level I do something like

LA:= LinearAlgebra:
...
LA:-LinearSolve(...)

Or In a procedure or module:

uses LA= LinearAlgebra;
...
LA:-LinearSolve(...)

I don't think that that example is adequately labelled in the help. I think that it should be labelled "A weird counterexample of what can go wrong due to automatic simplification". If you're just starting to learn Maple, you should ignore this, and probably also the whole use command. I've been a heavy user of Maple daily for over 20 years (with heavy programming experience in several other languages for 20 years before that). I've never used a nested use statement, let alone one whose outer part redefines a variable that is part of the redefinition of the inner part! I say this to assure you that there's no practical reason to learn this example---you'll never need to use it.

The only educational value of this example, in my opinion, is to make you rightfully wary of a somewhat mysterious process known as automatic simplification---which is necessary for efficiency but can lead to unexpected results. It is a preliminary step in the evaluation of expressions that happens before functions are evaluated (the order of evaluation is key to this). The use help page emphasizes that use statements are processed during the automatic simplification. The 2nd part of example 10 should state that the weird result is because b - b is also automatically simplified to 0. If you change that order of evaluation by replacing a - b with its inert form a %- b, and you evaluate that after both use statements are evaluated, then you'll get your expected outcome, (a+b)*a.

If you'd like to know a bit more, I can say more, but I'm only willing to if you have significant experience in Maple or some other language that allows subtle control of the order of evaluation. 
 

The csgn(p) that you got is a result of simplify. It could be avoided (for example, by assume= nonnegative as shown by Ronan), but here's another way. The procedure FractionalExponentAdjuster, below, takes 3 arguments

• P: a pseudo-polynomial, or a set, list, or other structure containing pseudo-polynomials, to be modified;
• x: the main variable of the pseudo-polynomials;
• X: the replacement for x in the returned true polynomials.

It returns two things:

• A modified structure of the same type as P except that the exponents of x have been integerized and x has been replaced with X;
• A procedure that reverts polynomials in X to pseudo-polynomials in x.

FractionalExponentAdjuster:= proc(P, x::name, X::name)
local d:= ilcm((denom@op)~(2, indets(P, identical(x)^rational))[]);
    subs(x= X^d, subsindets(P, identical(x)^rational, p-> X^(d*op(2,p)))),
    P-> subs(X= x^(1/d), subsindets(P, identical(X)^posint, p-> x^(op(2,p)/d)))
end proc
:
#Applying this to your example:
(new,res):= FractionalExponentAdjuster([NSR, deltaa], q, Q);
qu:= quo(new[], Q, 'r');
qr:= res([qu,r]);
#Test. Should get 0 if it's correct:
expand(qr[1]*deltaa + qr[2] - NSR);