Here's a suggestion: stabilize the plot to the unit circle by dividing by v; get rid of the view option. This makes animations that vary n or m much easier. So here's my version, a modification of your cycler from Reply "without t", not the one with the circles. I also added _rest to the plot command to make it easier to pass in plot options.

cycler := proc(k, p, m, n, T) local expr, t, u, up, v;
     u := exp(k*I*t);
     up := exp(-k*I*t*p);
     expr := exp(I*t) * (1 - u/m + I*up/n);
     v := 1 + abs(1/n) + abs(1/m);
     plots:-complexplot( expr/v, t = 0 .. T, axes = none, _rest);
end proc:

And here's an animation varying n. Note that I vary it exponentially.

plots:-animate(
     cycler, [5, 3, 2, 10^t, 2*Pi, color= purple], t= -2..1.5,
     frames= 100, paraminfo= false
);

And here's one varying m, also exponentially:

plots:-animate(
     cycler, [5, 3, 10^t, 3, 2*Pi, color= orange], t= -2..2.5,
     frames= 100, paraminfo= false
);

@Jerome BENOIT 

No version of Maple has ever shown a module's body, which is the executable code after the declarations. Indeed, that code is discarded after it's executed; it's not stored in the module. What eval shows (or used to show) is the module's header or shell, which includes the description, the options, and the names (but not the values, if any) of the locals and exports.

@Alejandro Jakubi What if you set interface(verboseproc= 2)?

@MDD 

A module is a Maple data structure similar to a procedure that allows for a special type of local variable called an export which can be accessed outside the module. It is the primary structure in Maple for object-oriented programming, similar to a class in C++ or Java. Often, the exports of a module are procedures which allow controlled access to the locals. See ?module. Sometimes a module is used primarily or even exclusively as a container object like a table. See ?record.

This has nothing to do with the algebraic structure known as a module.

@Haley_VSRC 

Markiyan is using the DirectSearch package, which must be downloaded from the Maple Applications Center. It's a very good package with many different algorithms for nonlinear fitting. But, as you can see, several of those algorithms return "crazy" results with c > 1.

@Haley_VSRC 

Here's how to use my procedure. In the final graph, note that there's a trend in the rightmost quarter or so of the data that is not explained by either curve.

Download RecenteredPowerFit.mw

@tomleslie The procedure that throws the error, `dsolve/numeric/DAE/make_proc`, is a monster: 792 lines and 36 parameters (as of Maple 18). The problem starts when floats in the equation are converted to exact rationals in line 22 and ends with the error message in line 719. I haven't traced what happens in between---it's a nightmare. It looks like the procedure has become a patchwork quilt over the years as features have been added to dsolve(..., numeric). 

The same bug is manifested if the coefficient 3 is changed to 3.0.

@Haley_VSRC Would you please check the value of c that you transcribed above? I think that you may be off by a decimal place. I concur on your value of A (given your b and treating the first four points as outliers), but I get c = 0.35.

Anyway, c > 1 is impossible, since the data are concave down.

If you use my method and make just the first point an outlier, you'll get

[A = 4.32368499833578, b = 0.335082182570315e-4, c = .442173738481387].

Using my method decreases the average squared residual by a factor of more than 6 over your method.

Very nice. I love ornate pentagrams. I've figured out what the parameters k and T do just by inspection. What do p, m, and n do? And why is t a parameter rather than a local? Surely it makes no sense for t to be anything other than a name.

@MDD I use the functional operator form (the arrow form) when a procedure is simple enough that it qualifies for it. The procedure Variables above is essentially equivalent to 

Variables:= proc(e, p::{set,list,rtable}(name)) 
     indets(e, And(name, Not(constant))) minus convert(p,set)
end proc:

just like f:= x-> x^2 is essentially equivalent to f:= proc(x) x^2 end proc.

See help page ?operators,functional.

@lham You wrote:

for w^0 , is it correct ?
coeff(ex,w,0)/w^0+coeff(ex, w, -1)/w + coeff(ex, w, -2)/w^2;

Yes, it is correct. The expression in Question doesn't have any w^0 terms (also called constant terms), but, if it did, that would be the way to extract them.

-1 or -2 in above what it means ?

It's the exponent of w (since 1/w^2 = w^(-2)).

and another question , i want to write original equation without any factoring 

Use the expand command.

Please put your Questions in the Questions section, not the Posts section. I moved this one for you.

@Axel Vogt 

I don't understand the purpose of your reformulation. Yes, it is interesting that Maple can perform that symbolic integration of the MeijerG expression in an instant. Perhaps that was your point. But the Int/diff expression in Question doesn't use the integral of the MeijerG expression; rather, it uses the integral of the square of the derivative of the MeijerG expression. This is much more complicated.

@Axel Vogt 

Here is my simplest "clean" interpretation of the Int/diff expression. By "clean", I mean that each of the three nested definite integrals has its own dummy variable of integration which is not used outside that integral:

H3p_Clean:= proc(ms::algebraic, b::numeric, eps::positive:= 0.5*10^(1-Digits))
local x:= indets(ms, And(name, Not(constant))), D, X, Y;
     if nops(x)>1 then
          error "1st argument must be an expression of at most 1 variable"
     end if;
     x:= x[];
     D:= diff(ms,x);
     evalf(
          subsindets(
               Int(
                    diff(
                         subs(x= Y, D)*Int((-b*X+1)*Int(D^2, x= 0..X), X= 1..Y),
                         Y
                    )*subs(x= Y, ms),
                    Y= 0..1
               ),
               specfunc(anything, Int),
               J-> Int(op(J), epsilon= eps)
          )
     )
end proc:

(I hope that my indentation, line break, and parenthesis style serves to elucidate rather than obfuscate the expression for you.)

In all cases that I've tried, this produces the same numeric results as the original "sloppy" version (posted in the Answer above). (By "sloppy", I mean that the same variable is used for all integrations and differentiations, and it's also used in the limits of the inner integrals.) But the weird thing is that in all cases the sloppy version ran significantly faster, usually by a factor of 2. So maybe the sloppy version is better.

I tried all of the following for the first parameter, ms: x, x^2, x^3, sin(x), cos(x), exp(x), exp(-x^2), sin(x)+cos(2*x). For each, I used both 0 and -1 for the second parameter, b. I also used the original MeijerG expression with b = .7. I varied the order in which the two integrals were done.

I have Digits set to 15, but I never used an epsilon smaller than .5e-10.

You could do an animation where each frame was one of a sequence of parallel planes intersecting the solid. In each plane, color would represent the value of the function. If you've ever seen an animation of a CAT scan or MRI, you'll know what I mean.