You should use UpperCase Int instead of lowercase int, if you want to evaluate numerical.
And here it is better to use 3/10 instead of 0.3:

  Int((diff(-ln(1-Fy), y))*fy, y = -infinity .. infinity): 
  IntegrationTools:-Change(%, y-3/10 = t, t);
  #convert(%, erfc);
  evalf(%); # using Digits:=15

                   infinity
                  /
                 |                        2
                 |                  exp(-t )
                 |          - --------------------- dt
                 |               /            1/2 \
                 |               |         t 2    |
                /             Pi |-1 + erf(------)|
                  -infinity      \           2    /


                          0.903197285568625

You may write S1 := [allvalues(sol)]; to have a list of the 4 solutions (of a 
general polynomial of degree 4, so already this is quite lengthy):

map(length, S1);
                       [2698, 2698, 2698, 2698]

Now at least you can do it for each of them (if it makes sense):

S2 := eval(S1, PARAM): # now a list, output is suppressed using ":"

map(length, S2);
                   [116652, 116652, 116652, 116652]

If you assume, that 1 printed page has 80 columns and 60 lines, then each of the
entries (having 116652 characters) would need ~ 24 pages to be printed, and thus
about 100 pages overall.

It usually would not make much sense to show that on a screen (though the
classical interface could do it, I used it with M17 for your task).

- (1^r) vs. (-1)^r

I stick to the first notation of f. For me that is not a function, since RootOf stands
for the set of solutions (hence there is no unique number assigned to n).

One has to select for the roots. And I simplify the results. Then 2 cases remain:

[allvalues(f(n))]: 
simplify(%): evala(%);

h:=unapply(%[1],n);
g:=unapply(%%[2],n);

   h := n -> -1/3*(6*n^2-(21*n^2-24*n+7)^(1/2)-6*n+2)/(2*n^2-3*n+1)

Considering the first gives

[solve(h(n), n)]; 

                               1/2          1/2
                             33           33
                      [1/4 - -----, 1/4 + -----]
                              12           12
map(h,%): simplify(%);

                                [0, 0]


The second possible selection is interesting, it has no solution.

I am using 32 Bit on Win 7

theDLL:="C:\\WINDOWS\\SYSTEM32\\urlmon.dll";

URLDownloadToFile := define_external(
  'URLDownloadToFileA',
  pCaller::integer[4], 
  szURL::string,
  szFileName::string, 
  dwReserved::integer[4], 
  lpfnCB::integer[4],
  'RETURN'::integer[4] ,
  LIB=theDLL):

Url:= " ... "; # as string

myDirectory:= "d:\\temp";
myFile:=      "data.csv";
Destination := cat(myDirectory, "\\", myFile);

DL:= proc() URLDownloadToFile(0, Url, Destination, 0, 0) end proc;
DL(); # now download

-3*b*k*u^2-3*b*k^2*u^4-k^3*u^6*b+k*u+5*k^2*u^3-b;
subs(b=1, k=1, %);
[solve(%, u)]: evalf(%);


  [0.794972852988398 + 0.401160655470270 I,
        -0.102016745838554 + 0.541867900596280 I,
        -0.692956107149844 + 1.91520931667072 I,
        -0.692956107149844 - 1.91520931667072 I,
        -0.102016745838554 - 0.541867900596280 I,
        0.794972852988398 - 0.401160655470270 I]

In my second live I work as privacy officer. And as such I already would stop using
that service at registration: the most idiotic thing I can imagine, that already at
that stage Google analytics is present and tracking.

Similar thoughts for your other data source, which uses Amazon's cloud.

Due to politeness I do not want to comment on Maple :-)

I think it is possible to download such files without browser or Maple in anonymous
way (using WIN DLLs or wget) and that this is a better idea.

In your case actually Maple does it "only" numerically, try it with 32/10 instead of 3.2

Z / nZ = Z / (-n)Z, that's all ...

This is a polynomial of degree 6 and the command 'irreduc' returns true, so it is not likely to be solvable by radical expressions

Setting k=1, b=1 and using fsolve(%, complex) shows, that it may have only non-real roots

The answer is: yes, it has no roots.

That follows by looking at Eigenvalues and Eigenvectors, using linear Algebra only.
The appended sheet shows it and I hope it is correctly written down.

MP_primitive_matri.mws

MP_primitive_matri.pdf

edited: changed file names

You may use "signum".

eq := x = y*(25+2*x)^(2/3)/(25*(.566*(25*x)^(2/3))); 

[seq( eq, y in [1,2,5])];
map(fsolve, %);

    [.205293886670198, .312212133156964, .544930149205805]


Or if you have written it in rational notation you will end up with

RootOf(113325935*_Z^15-256*_Z^6*y^3-6400*_Z^3*y^3-40000*y^3, index=1)^3;
[seq(%, y in [1,2,5])]; 
evalf(%);

    [.205293886670197, .312212133156964, .544930149205804]

why do you expect that? how would you prove it?

sqrt(1+x^2+y^2);
int(%,z=-1..2);                       # does not depend on z, so kill it
Int(%, y=-sqrt(8-x^2)..sqrt(8-x^2));  # and the 2nd integral is 1-dim
Change(%, y=sqrt(8-x^2)*eta, eta);    # get rid of variable bounds
value(%);                             # solve it
Int(%, x=0..2*sqrt(2)); simplify(%);  # set up final task, keep it simple
value(%);                             # now finish it

                                26 Pi