@Preben Alsholm Is there some reason (that I didn't see) that you suspect that the OP is using Maple 12? 

@jediknight The nonreal value that you got, 0.5730486817*I, is in fact the function's value at one of the roots of its derivative, but, as I said, it makes no sense to me that maximize would return it. So, let's assume that there's a bug in maximize in your version of Maple. There's an easy alternative: The Calculus I method of finding the maximum value when the function is evaluated at the (real) roots (or zeros) of its derivative:

restart:
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:= max(eval~(a, wx=~ [fsolve](numer(diff(a, wx)))));

@jediknight I don't understand it either. A nonreal result from maximize makes no sense to me. What Maple version are you using? If I directly copy-and-paste your code into Maple 2018 and Maple 2022 (the two versions that I happen to have open at the moment), I get

restart:
Top_of_Q1= maximize(
    (((8*wx^2*(6.3-1)/(Pi^2*sqrt((6.3*wx^2-1)^2+1^2*wx^2*(wx^2-1)^2*(6.3-1)^2)))))
);
                    Top_of_Q1 = 0.8281966930

which seems correct.

@Wes If moy is a Matrix, Array, Vector, or rtable (not a matrix, array, vector, or table) with a single element, it can be converted to that single element by

seq(moy)

@Wes You wrote:

• As you describe, there is not direct function to calculate p-value.

There is a command Probability that could be used like this:

T:= Statistics:-RandomVariable(StudentT(23)):
p_value:= Statistics:-Probability(abs(T) > 1.96);
                       0.0622210380605361

• I have read that for bi-latteral test
  p-value = 2*P(ST >|St| | H0 true) = 2*(1-CDF(abs(St)).

For a symmetric distribution, 1 - CDF(T, abs(St)) = CDF(T, -abs(St)), so the expressions are (theoretically) equal. The form that I gave is computationally safer due to rounding error.

@Wes Good question. It helps to visualize the p-value as the area in the "tails" of the distribution. That might be the left tail, the right tail, or the sum of both tail areas; it depends on what type of inequality is in your "alternative hypothesis"--- x < a (left), x > a (right), or x <> a (both). Here, x is some statistical parameter (such as mean) that you're testing, and a is some fixed real number. (Let me know if you need more details on any of that.)

Suppose that T is the test distribution (such as Chi^2 or Student's t) (which is not the underlying distribution of the raw data, such as Normal), and t is the value of the test statistic (based on some computation, often elaborate, done with the raw data). Then the p-value for a 

• right-tailed test is 1 - CDF(T, t),
• left-tailed test is CDF(T, t),
• two-tailed test on a symmetric test distribution (such as Student's t) is
  2*CDF(T, -abs(t)),
• two-tailed test on an asymmetric distribution (such as Chi^2 or F)... I need to defer to another expert's opinion on that; I don't know off the top of my head.

@nm When a symbol appears as a left operand of ->, that is its declaration.

@Carl Love I wrote above:

• It's fairly easy to customize the number of terms in the series to your value of Digits. The series is alternating, so Leibniz's Theorem on the error of truncated alternating series applies.

Actually, it's so easy to do this that I couldn't resist writing it up and posting it here. Using a procedure of only two lines to numerically evaluate the asymptotic series, we can get results that are several times more efficient and several digits more accurate than the default numeric evaluation of your function. 

In the code below, I've omitted your factor of 4. 
 

Download AsymptEvalf.mw

@Carl Love Here's an easy-to-understand and purely algebraic alternative:

subs(x= x-1, collect(subs(x= x+1, p), x));

The first-degree term expands automatically. To prevent that, you can do

subs(x= ``(x-1), collect(subs(x= x+1, p), x));

@MathPrincess123 Your concept of long division is completely wrong. The first term of the quotient should be the quotient of the highest-degree terms, not the lowest-degree terms. Perhaps you are being confused (visually) by your sort order. Descending degrees is the usual order, just like ordinary integers (where the degrees are the exponents of 10).

Also, it can be clearly seen that my program doesn't make any "change" to the polynomials other than replacing q with Q, because there are no fractional or negative exponents. The quotient is the same as it would be under any division process, whether by hand or computer. In this particular case, the quotient of the highest-degree terms is the degree-0 term of the quotient.

This does not need to be your "last question". Feel free to keep asking until you completely understand.

@MathPrincess123 

I thought that you might want to handle the negative-exponent case, but I didn't include it because the quotient and remainder need to be treated separately. To restore the original variable, the exponents of the remainder need to be reduced in the negative direction, but the exponents of the quotient do not.

So, add this procedure:

QuoRem:= proc(n, d, x::name)
local X, ND, R, m, q, r;
    (ND,R):= FractionalExponentAdjuster([n,d], x, X);
    m:= min(0, ldegree~(ND, X)[]);
    q:= quo(expand(ND/~X^m)[], X, r);
    #Remainder gets downshifted, but quotient does not:
    R(q), R(expand(X^m*r))
end proc
:

To use it, simply do

(qNSR, rNSR):= QuoRem(NSR, deltaa, q);
expand(qNSR*deltaa + rNSR - NSR); #Test---should get 0

And, no, it was not "an easy question".

@Wes I don't think that you understand the meaning of CDF, PDF, and Quantile. If X is a continuous random variable, and x is a real number, then CDF(X, x) is the probability that X <= x. So, CDF returns a probability, a number between 0 and 1. PDF(X, x) is the derivative with respect to x of CDF(X, x). It is mainly of theoretical interest; there's no practical value to evaluating it at a specific number such as with your attempt PDF(Y, 0.05). Quantile(X, p) is the functional inverse of CDF(X, x); in other words, it's the solution x of the equation CDF(X, x) = p. Note that p here is a probability.

@max125 What output were you expecting? If it's [2, 7], it can be obtained as 

(f@op)~([[2,0], [3,4]]); 

@vv After doing several experiments replacing the bindings with modules (either nested or unnested), I agree with you that it's a bug; the result should be (a+b)*a. For example, nested modules:

restart:
A:= module() export a:= :-a+b, B:= module() export b:= a - :-b; end module; end module:
use A in use B in a*b end use end use;
 

@vv My guess is that the order that the automatic simplifications are applied makes the difference.