Have you switched off to send a HTTP referer? Or are you using other settings for security and privacy?

yes, this example leads to the same presentation

concrete_example.pdf

Let me try to explain the reasoning.

1. Estimate the absolute value of the integral
 
   abs( Bint ) <= 
   1/n * Int (abs(arctan) * abs(continousFunction)) dx <=  
   1/n * Int( Pi/2 * max ) <= 
   1/n * constant 
   ---> 0

2. Maple has a sloppy presentation for the partial integration, 
   actually it means to take limits for the term named T below:

  A0:=Int(x*cos(x)/(1+3*sin(n*x)^2), x);
  IntegrationTools:-Parts(A0,x*cos(x));
  T:=remove(has, %, Int);
  Tc, Tf:=selectremove(has, %, arctan);

                             /
                            |     x cos(x)
                     A0 :=  |  --------------- dx
                            |                2
                           /   1 + 3 sin(n x)


      arctan(2 tan(n x)) x cos(x)
  1/2 ---------------------------
                   n

             /
            |      arctan(2 tan(n x)) (cos(x) - x sin(x))
         -  |  1/2 -------------------------------------- dx
            |                        n
           /


                          arctan(2 tan(n x)) x cos(x)
                 T := 1/2 ---------------------------
                                       n


                                                x cos(x)
              Tc, Tf := arctan(2 tan(n x)), 1/2 --------
                                                   n

One needs the directed limit of T = Tc * Tf in a and b and since Tf
is continous that reduces to look at Tc:

  # limit in x=a
  Limit(Tc, x=(2*j-1)/n*Pi/2, right): 
  '%' = value(%) assuming (j::posint, n::posint);

                                                        Pi
                  lim           arctan(2 tan(n x)) = - ----
               /(2 j - 1) Pi\                           2
          x -> |------------|+
               \    2 n     /

  # limit in x = b = a + Pi/n
  Limit(Tc, x=(2*j-1)/n*Pi/2 + Pi/n, left): 
  '%' = value(%) assuming (j::posint, n::posint);

                                                           Pi
                    lim              arctan(2 tan(n x)) = ----
             /(2 j - 1) Pi    Pi \                         2
        x -> |------------ + ----|-
             \    2 n         n  /


The actual reason is tan(n*x), which for x=a or b is Pi*j +- 1/2*Pi and those
are just the points where tan jumps from -oo to +oo

  discont(tan(z), z);
                          {Pi _Z1 + 1/2 Pi}

please post it "readable", as ASCII or upload or what ever, but nobody would like to type in your problem.

As it was said before: there is a symmetry, up to a linear shift (preserving
polynomial nature), h:= t -> f( (t+1)/2 ) - Pi/4 over -1 ... 1, and h(t)/t 
is symmetric w.r.t. the y axis.

Now approximat H(z) = h(sqrt(z))/sqrt(z) on 0 ... 1 only, by minimax degree 9
(the system does not like higher degrees) and passing to squares extends to
the desired full interval -1 ... 1 (i.e. one enforces it to be even).

Rewriting gives what I posted.

Edited: I append a sheet 

http://www.mapleprimes.com/ViewTemp.ashx?f=492_1388687933/approx_arcsin@sqr.mws

ah:= t ->
     (.49226171242818 + (1.35759075917206 + (-34.5029313050447 + (360.49576035870 +
     (-1884.58266260998 + (5535.13672335059 + (-9550.58923533072 + (9605.70338813121+
     (-5210.92343814689 + 1178.19020295633*t^2)*t^2)*t^2)*t^2)*t^2)*t^2)*t^2)*t^2)*t^2)*t

Then f(x) ~ ah(-1+2*x) + Pi/4 on x = 0 .. 1 with an infnorm of 0.00773828760171735, Digits = 15

@acer do you mean by arcsin(t) = Pi/2 - 2*arcsin( sqrt( (1-t)/2 ) ) ?

happy new year :-)

translate by "eval( ... , T = orthopoly[T])"

that worked for me:

Digits:=100;
chebpade(f(x), x=0 .. 1, 10): eval(%, T = orthopoly[T]);
cp:=unapply(%,x);
Digits:=15;

infnorm fails for me

infnorm(f(x)-cp(x), x=0..1, 'xmax');

  0.023208925224282...

xmax;
  0

I am aware that the approximations (almost) never can be extended beyond the
range they where built for. It was meant to reduce it to one half of interval
(and thus having only one ugly boudary situation)

For your PPS: you may try on 0 ... 1 - epsilon and 'pray'. 

Also you can try chebpade (should be faster and is often almost as good as
minimax. Or Chebyshev (as suggested)

But meanwhile I guess you want to show how ugly it can be, practically.

I never looked in Rudin for that 

I think the problems are in x=0, x=1 and its derivatives.

Note that f:= x -> arcsin(sqrt(x)) is symmetric in x=1/2, so one may want to
consider only one of those intervals. 

Now doing that with Digits = 15 and using 'numapprox/minimax' in a brute way:

minimax(f, 1/2..1, [9,0], x -> 1/abs(f(x)), 'maxerror'); # relative errors
maxerror;

                         0.00743964854436121

minimax(f, 1/2..1, [9,0], x -> 1, 'maxerror');
maxerror;

                           0.01097586602600



For your approach one may try Chebyshev polynomials, transforming the task
to -1 ... 1, for g:= x -> f( (x+1)/2 )

Perhaps it would help, if dipamilo explians a bit, why he asked the question.

Here is a trick

v:= x -> Int('xi -> (exp(-(xi-x)^2)*exp(xi))',  -infinity .. infinity, method = _d01amc);
 
  evalf( v(0) );
                           2.27587579446875

  evalf( v(1) );
                           6.18647181593419

Confirm the last one:

  Int((exp(-(xi-x)^2)*exp(xi)),  xi= -infinity .. infinity);
  eval(%, x=1);
  evalf(%);

                           6.18647181593419

Have not tried it: in the link above you can find the original code. File extension mpl means pure text. Have you tried to use that?