I used upper case Int and Digits:=15 to get 0.187286133249768

Int(exp(-b*x)/(exp(-2*b*x)*a+exp(-4*x)),x):
IntegrationTools:-Change(%, x=ln(t),t): simplify(%) assuming 0<t; #simplify(%, symbolic);
value(%):
simplify(%) assuming  b::real, 0<t;
#convert(%, hypergeom);
                         /      (-b + 3)
                        |      t
                        |  ----------------- dt
                        |   (-2 b + 4)
                       /   t           a + 1

             (-b + 4)            (-2 b + 4)        b - 4
            t         LerchPhi(-t           a, 1, --------)
                                                  -4 + 2 b
          - -----------------------------------------------
                               -4 + 2 b

You may try the following to study the task:

#Eq1:=Eq1*omega__n^5:
#Eq2:=Eq2*omega__n^5:
sys := { Eq1 , Eq2 };

eliminate(%, [p]): map(simplify, %);

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
 

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.

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).