Axel Vogt

5408 Reputation

20 Badges

17 years, 229 days
Munich, Germany

MaplePrimes Activity


These are answers submitted by Axel Vogt

I think that your integral is sol := 2*R/Vzero*InverseJacobiAM(1/2*arccos(1/3*(2*R*g+Vzero^2)/g/R),2*I/Vzero*R^(1/2)*g^(1/2))

I do not have a reasonable idea for the limit or series in Vzero, but plotting shows that it explodes

MP_226316_plot.mws
 

# https://www.mapleprimes.com/questions/226316-Why-Does-This-Integral-Evaluate-To-Infinity

restart; interface(version);

`Classic Worksheet Interface, Maple 2017.3, Windows, Sep 27 2017, Build ID 1265877`

(1)

sol := 2*R/Vzero*InverseJacobiAM(1/2*arccos(1/3*(2*R*g+Vzero^2)/g/R),2*I/Vzero*R^(1/2)*g^(1/2));

sol := 2*R*InverseJacobiAM((1/2)*arccos((2*R*g+Vzero^2)/(3*g*R)), (2*I)*R^(1/2)*g^(1/2)/Vzero)/Vzero

(2)

Sol:=subs(g=ScientificConstants:-GetValue(ScientificConstants:-Constant(g)), R=3, sol);
plot(Sol,  Vzero = 10^(-4) .. 1.5*10^(-3) );

Sol := 6*InverseJacobiAM((1/2)*arccos(0.113301801441992e-1*Vzero^2+.666666666666668), (6.26311424133394*I)*3^(1/2)/Vzero)/Vzero

 

plot(Sol,  Vzero = 0 .. 1.5*10^(-3), smartview=false);

 

 


 

Download MP_226316_plot.mws

 

I use 'rationalize' and instead of op(...) I write ln = ln@rationalize (so first rationalize and then take log). Similar for the second and more complicated example

eval(f, ln = ln@rationalize); #completesquare(%, x);
                                       2
                                (x - 1)
                             ln(--------)
                                   4

 

Find a suggestion appended for your first task: you can "eliminate" the variables Io and Rs, now solving for n only (though it needs higher Digits).

Note that it is a bit questionable since you have only 4 - 5 decimals in your input and I do not want to check sensitivity (it is a must here for practical reasons, I guess).

n ~ 0.9941, Io ~ 0.4431e-11, Rs ~ 1.160

MP_225728.mws

I depends how Maple has implemented the function, for the (extreme) tails one may use erfc. That is quite fast and exact.

1-erf(x): convert(%, erfc) =%;
                         erfc(x) = 1 - erf(x)

Digits:=32;             # or higher
erfc(x)=1e-20;          # complementary
#ln(erfc(x))=ln(1e-20); # not needed here
b:=fsolve(%, x=6);

                b := 6.6015806223551425615163916324187

 

# using Maple 2017

(1-x^floor(u))/((1-x)*u^2); eval(%, x=-1);
 plot(%, u = 1 .. 21);

suggests

1/2*(1-(-1)^floor(u))/u^2; #eval(%, u=k);
Int(%, u= 2*k-1 .. 2*k);
value(%) assuming k::posint;
Sum(%, k=1 .. infinity);
value(%);

giving ln(2)

Not sure about the very question but

J:=eval(Is1 - Is2, [t=x+I*y, s=1, omega0=1]);

convert(J, hypergeom);
simplify(%);

gives zero (using Maple 17)

 

For MS Windows there is an indexing service and you can tell it to look for the content of specific file types (= file extension wm or mws) instead of filenames only. Then the service considers text in the file.

Now you can use the Windows Filemanager to search.


 

# https://www.mapleprimes.com/questions/223750-Kernel-Connection-Lost-During-Summation

restart; interface(version); Digits:=15;

`Standard Worksheet Interface, Maple 2017.3, Windows 7, September 27 2017 Build ID 1265877`

 

15

(1)

R0 := exp((2*Pi*I)*n^2*z);
z:=exp(I*Pi/k);
#R1 := sum(R0, n = -infinity .. infinity);
R1 := Sum(R0, n = -infinity .. infinity);
R1 := abs(R1)^2;
R2 := exp((2*Pi*I)*(n+1/2)^2*z);
#R2 := evalf(sum(R2, n = -infinity .. infinity));
R2 := (Sum(R2, n = -infinity .. infinity));
R2 := abs(R2)^2;
#R := evalf(sqrt(Im(z))*(R1+R2));
R := (sqrt(Im(z))*(R1+R2));

evalc(R):
simplify(%) assuming 1<k: combine(%) assuming 1<k:
Student[Precalculus][CompleteSquare](%, n): factor(%):
f:=unapply(%, k);

# some checks
#f(1+1/13): evalf(%);
#eval(R, k=1+1/13): evalf(%);
#f(1+1/1000): evalf(%);
#eval(R, k=1+1/1000): evalf(%);

 

plot(f, 1 .. 10);

 

plot(f, 1+1/10 .. 3);

 

 


 

Download 223750.mw

floor(1.061153846*10^7);
                               10611538

 

round(1.061153846*10^7);
                               10611538

 

The given command does not expand the integral. It first computes the integral (lower case int, not Upper Case Int) - which is a Bessel function.

And then it expands that result.

 

For your logarithmic integral Li you may try

eval(Li(x), x=exp(t));
                              Li(exp(t))

MultiSeries:-asympt(%, t);

       /120    24     6      2      1              1   \
       |--- + ---- + ---- + ---- + ---- + 1/t + O(----)| exp(t)
       | 6      5      4      3      2              7  |
       \t      t      t      t      t              t   /

 

M1 := (t,lambda1,k,lambda2) -> exp( -(1/2)*(log(1-2*lambda1*t) + k*log(1-2*lambda2*t)) );
Int( diff(M1(z,2,9,1/2),z)/sqrt(abs(z)),z=-infinity..0 )/GAMMA(1/2);
simplify(%); # before evaluation
value(%);
evalf(%), evalf(%%); # check

                  2.46582298893209, 2.46582298893238

You also may try the command "timelimit" (and just output the loop index for later investigation).

I often prefer to switch to fixed integration bounds. Then I get it to work.


 

# https://www.mapleprimes.com/questions/223127-Diffintfxt-T0xx

restart;
F:=(x,t) -> 1/(1+exp(1/(x-t)));

F := proc (x, t) options operator, arrow; 1/(1+exp(1/(x-t))) end proc

(1)

Diff(Int(G(x,t), t=0..x), x);
``=Change(%, t=tau*x, tau): subs(tau=t, %);
eval(%, Diff=diff): combine(%); #: simplify(%);

'eval'(rhs(%), G=F); #combine(%, Int):
``=simplify(%); #map(Tryhard2,%); #simplify(%, size); map(collect,%,x);

J:=rhs(%):
v1:=value(J) assuming x<0:
v2:=value(J) assuming 0<x:
piecewise(x<0, v1, 0<x, v2, x=0, `?`):
``=simplify(%);

Diff(Int(G(x, t), t = 0 .. x), x)

`` = Diff(x*(Int(G(x, t*x), t = 0 .. 1)), x)

`` = Int(x*((D[1](G))(x, t*x)+(D[2](G))(x, t*x)*t)+G(x, t*x), t = 0 .. 1)

eval(Int(x*((D[1](G))(x, t*x)+(D[2](G))(x, t*x)*t)+G(x, t*x), t = 0 .. 1), G = F)

`` = (1/x)*(Int(((t*x-x-1)*exp(-1/((x*(t-1))))+x*(t-1))/((t-1)*(1+exp(-1/((x*(t-1)))))^2), t = 0 .. 1))

"={[[`?`,x=0],[(1)/(1+(e)^((1)/(x))),otherwise]]"

(2)

F(x,0); plot(%, x= -2 .. 2, discont=true);

1/(1+exp(1/x))

 


 

Download MP-223127.mws

I am not very familiar with the G function, so the following is a bit formal.

Maple's notation with 'empty parameters' occures if some cancel out. Conversely one
can recover by feeding them (generically and in valid ranges).

The task means MeijerG([[a], [b]],[[c], [d]],z) with b=c.

Now take the series presentation in z=0 from the FunctionAdvisor, [b=c, d=1, a=1/2],
and ignoring possible issues (radius of convergence?)

The summands are -GAMMA(1/2+c+k)/Pi* sin(Pi*k) /GAMMA(c+k) * z^(c+k)*(-1)^k.

This is zero (if c is not a negative half-integer).

> [seq(2*n+1, n= -4 .. 4)];

                   [-7, -5, -3, -1, 1, 3, 5, 7, 9]

> map('q -> q mod 3', %);

                     [2, 1, 0, 2, 1, 0, 2, 1, 0]

>

 

3 4 5 6 7 8 9 Last Page 5 of 89