Here is related to that bug in int, in Maple 12.02

i:=convert(EllipticF(infinity,3+2*sqrt(3)),Int);

          infinity
         /
        |                                 d_alpha1
  i :=  |          -------------------------------------------------
        |                      2 1/2              1/2 2        2 1/2
       /           (1 - _alpha1 )    (1 - (3 + 2 3   )  _alpha1 )
         0

v:=value(i);

                                              /         1/2\1/2
                                              |60 + 36 3   |
                         1/2                  |------------|
                        3                     |        1/2 |
        2 EllipticK(------------)             \ 7 + 4 3    /
                            1/2     EllipticK(-----------------) I
                    3 (2 + 3   )                      3
   v := ------------------------- - ------------------------------
                      1/2                            1/2
               3 + 2 3                        3 + 2 3

evalf(i)=evalf(v);

             -10
     0.123 10    - 0.5052838825 I = 0.4889536878 - 0.5052838829 I

Here is another flavor of it,

i:=convert(EllipticF(infinity*I,1/2),Int);

           infinity I
          /
         |                             2
   i :=  |            ----------------------------------- d_alpha1
         |                        2 1/2             2 1/2
        /             (1 - _alpha1 )    (4 - _alpha1 )
          0

v:=value(i);

                                        1/2
                                       3
                        v := EllipticK(----) I
                                        2

evalf(evalf(i))=evalf(v);

                  0. - 2.156515648 I = 2.156515648 I

An additional surprise is that one evalf is not enough for evaluating i - two evalfs are needed!

Alec

The easiest, probably, is to use Matlab - it has dct in the Signal Processing Toolbox.

Alec

It is rather easy to see that that limit equals -EllipticCK(k). The (positive) value of c is irrelevant, because it can be made 1 by multiplying x by c. In particular,

limit(I*EllipticF(I/z,k),z=0,right)=-EllipticCK(k);

              lim    EllipticF(I/z, k) I = -EllipticCK(k)
            z -> 0+

evalf(eval(%,k=3+2*sqrt(2)));

                 -0.5430459002 - 0. I = -0.5430459002

Note also

convert(EllipticCK(k),EllipticK);
                                        2 1/2
                        EllipticK((1 - k )   )

Alec

The following conversions to hypergeom are also interesting,

convert('SphericalY'(0,0,0,0),hypergeom);

                                  1
                               -------
                                   1/2
                               2 Pi

convert(SphericalY(0,0,0,0),hypergeom);

                                  0

Alec

evalf[4] does all calculations with 4 digits (it seems as if it counts "-" sign as a digit as well), and evalf[5] - with 5 digits. If you do calculations with more digits, you get more precise result.

For just rounding of the result calculated with, say, 10 digits, you have to first calculate it with 10 digits (by using just evalf without indexes), and then evalf[4] would use the remembered more precise results and round it. By the way, if you execute efalf[4] after evalf[5], it will also round the more correct result instead of recalculating it with 4 digits.

Alec

?dsolve,numeric

Alec

with(Student:-Calculus1):
infolevel[Student[Calculus1]] := 1:
J:=-2*Pi*(Int(sqrt(-3*u^2+4), u = 1 .. 0)):
Hint(J);

                    1/2                              4       2
  [change, u = 2/3 3    sin(u1), u1], [change, -3 + ---- = u1 , u1],
                                                      2
                                                     u

                      /   1/2    \1/2
                      |2 3       |
                      |------ - u|
                      |  3       |
        [change, u1 = |----------|   , u1]
                      |   1/2    |
                      |2 3       |
                      |------ + u|
                      \  3       /

> J:=Rule[%[1]](J);
Applying substitution u = 2/3*3^(1/2)*sin(u1), u1 = arcsin(1/2*u*3^(1/2)) 
with du = 2/3*3^(1/2)*cos(u1)*du1, du1 = 3^(1/2)/(-3*u^2+4)^(1/2)*du

                0
               /
              |        2     1/2
  J := -2 Pi  |   (-3 u  + 4)    du =
              |
             /
               1

                 0
                /
               |          1/2        2
        -2 Pi  |     4/3 3    cos(u1)  du1
               |
              /
                 Pi
                ----
                 3

Alec

Also, the formula LegendreQ(n,n,x) = f(n,x) gives the second solution for -1 < x < 1, with

f:=(n,x)->(-1)^n/2*doublefactorial(2*n-1)*(1-x^2)^(n/2)*ln((1+x)/(1-x))+
(-1)^n*doublefactorial(2*n-2)/(1-x^2)^(n/2)*x*
sum(pochhammer(1/2-n,k)/pochhammer(1-n,k)*(1-x^2)^k,k=0..n-1);

which can be tested by odetest,

seq(odetest(y(x)=f(n,x),(1-x^2)*diff(y(x), x, x)-
2*x*diff(y(x), x)+(n*(1+n)-n^2/(1-x^2))*y(x), y(x)), 
n=1..20);

      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

This value of LegendreQ should be tested in Maple with

_EnvLegendreCut:=1..infinity:

Alec

Excellent work, Axel!

The matrix, probably, can be saved, after calculating it first time, either in an .m file, or in a repository, and then reused.

Alec

One way is to express x, or y in your units - in millimeters if you need them, instead of meters (i.e. multiply coresponding values by 1000.)

Alec

You can plot with axes=none option and draw the axes manually, as either lines, or arrows, and adding tickmarks and labels manually as well.

Alec

FunctionAdvisor gives some formulas. Try FunctionAdvisor(sin), for example.

There is also a Dictionary, and Maxwell's equations, for example, can be accessed as ?Dictionary,maxwellsequationsofelectromagnetism .

Alec

This is generally well-known, see Eulerian numbers, for instance.

Alec

The recurrence at the end of Robert Israel's post can be also obtained by noticing that the l.h.s satisfies A(n+1)=x*diff(A(n),x) with A(0)=x/(1-x).

In more detail, writing A(n)=f(n,x)/(1-x)^(n+1), we get (using Maple),

simplify(f(n+1,x)=x*diff(f(n,x)/(1-x)^(n+1),x)*(1-x)^(n+2),symbolic);

  f(n + 1, x) =

           //d         \                           /d         \\
        -x ||-- f(n, x)| x - f(n, x) - f(n, x) n - |-- f(n, x)||
           \\dx        /                           \dx        //

That, actually, is enough to obtain the formula, without even writing the recurrence exactly. That tells that f(n,x) is a polynomial of x of degree n (for n>=1). The coefficients of it obtained through multiplication of series

f(n,x)=(1-x)^(n+1)*Sum(k^n*x^k,x=1..infinity)=

(Sum((-1)^(m-1)*binomial(n+1,m-1)*x^(m-1),m=1..n) + O(x^n)) * 
(Sum(k^n*x^k,k=1..n)+ O(x^(n+1))

give the original formula.

Also, the radius of convergence of the l.h.s. can be found in Maple,

limit(k^n/(k+1)^n,k=infinity) assuming n::posint;

                                  1

Alec

On this site, one can see a series of examples in Joe Riel's blog. See Faster Permutations, for instance.

Alec