with(Student[Calculus1]):
RiemannSum(1/x^2,x=50..75,partition=25,method=right,output=plot);
rightsum:=%:

The DLL is located in C:\programs_x86\Maple18\bin.win

restart;
f:= t-> exp(a*t):
Student[Calculus1][IntTutor](Int(exp(-s*t)*f(t), t= 0..gamma)); lprint(%);

and clickediclick results in 

Int(exp(-[]*t)*exp(a*t), t = 0 .. gamma) = Int(-exp(u)/(-a+[]), u = [] .. a*gamma-gamma*[])

Ok, so what is your actual question or task (in a precise manner)?

And what is the original reason for it?

First: you should not use "gamma", it is a numerical constant (except you are aware of that), try to use g or what ever.

Then: even if you have x and y (depending on z) it is not clear why Maple should find alpha and beta (now depending on z and g).

For finding x any y my guess is: you actually have some function and want to find f(x,y) = f(y,x). So you may wish go some steps back and want to understand the meaning - I would not expect Maple to find a symbolic solution.

So it may be not a bad idea to sketch the original problem.

There is no need to introduce another option, one can use it like for 
Digits or other cases and remember the setting

eq:=diff(y(x),x$2)+y(x)=0;
 
oldOrder:=Order; Order:=10;
dsolve({eq,y(0)=1,D(y)(0)=0},y(x),type='series');
Order:=oldOrder;

I always puzzled with that (refusing to understand it deeper). Meanwhile I prefer:

5*a*b; applyrule(a*b=y, %);

                                 5 y

Perhaps the following does what you want in general

eq21:=select(has, eq2, 1/Z(z));
 
#eq22=select(has, eq2, 1/R(r));
eq22 = eq2 - eq21; # or this ...

                                    2
                                   d
                                   --- Z(z)
                                     2
                                   dz
                           eq21 := --------
                                     Z(z)


                              2
                             d
                             --- R(r)   d
                               2        -- R(r)
                             dr         dr
                      eq22 = -------- + -------
                               R(r)     R(r) r

One should check a decomposition anyway

@one_man you think of Bezout or (real) Analysis?

Perhaps you should say where the curve is embedded, how it is given (parametric or as intersection of [hyper] surfaces or ...)  and if you are working in an algebraic or analytic setting and over which field (?). And whether you have singularities.

@Carl Love 

Thank you, I corrected mine.

Anyway your purely numerical way seems more sound and is even better
(faster and with less restrictions). I modified it a bit and then it
runs for Digits = 15 (imaginary part is similar, it should be ~ 0).

F := y -> (1-exp(-11/2*1/cos(y)))*sin(y);
H := x -> arctan(300*cos(x)+1/2*(49-360000*sin(x)^2)^(1/2));

Int(F(y),y = 0 .. H(x));
Change(%, y=eta*H(x), eta): subs(eta=y, %): combine(%, Int);
subsop(1 = Re(op(1, %)), %);  # to use only the real part
reG:=unapply(%, x);

evalf(Int(reG, 0 .. Pi));
                           3.13316050306219

I made an error assuming symmetry in x=Pi/2 (which is not true). Just splitting I get 3.13316050306238+.1e-16*I

I suggest the following modification for acers's sheet (that symbolic solution speeds it up):

auxint:=proc (eta, R) 
local result, t1, t2, t3, t4, t5, t6;
Digits := 20; 
if `not`(type(eta, numeric) and type(R, numeric)) then return ('procname')(args) end if;
t6 := -1/2*R; t5 := 1/2*eta; t4 := 1/R; t3 := exp(t6); t2 := Ei(1,1/2*R); t1 := Ei(1,R*t5); 
result := -t4+(ln(eta)*t3+t1)*t4/t2+(-1/2*t2+t1*t5+(-exp(eta*t6)+t3)*t4)/Ei(1,R); 
#evalf(%);
end proc;


Edited to give the code for using the formal solution:

g := proc (eta, Rey) options operator, arrow; (1/2)*sqrt(eta)*
  Ei(1, (1/2)*Rey*eta)/Ei(1, Rey)+(exp(-(1/2)*Rey)-exp(-(1/2)*
  Rey*eta))/(sqrt(eta)*Rey*Ei(1, (1/2)*Rey)) end proc;

'Int(g(x,R)/sqrt(x), x=1 .. eta)';
normal(%): map(collect, %, x):
 
value(%) assuming 1 < eta: collect(%, Ei);
  
codegen[makeproc](%, [eta,R]):
codegen[optimize](%, 'tryhard');
lprint(%);

Likewise one can convert to tan and succeed from there.

Note that I changed your 'indexing'.

  Int(tan(x)^(n-2)*sec(x)^2, x): 
  subs(n=n+2, %);
  convert(%, tan): simplify(%): 
  value(%);
                          /
                         |        n       2
                         |  tan(x)  sec(x)  dx
                         |
                        /


                           /sin(x)\(n + 1)
                           |------|
                           \cos(x)/
                           ---------------
                                n + 1

The first version works for me, using 18.02.

PS: Where I would prefer the notation finding it ugly anyway ...)

You are right, the 2nd is an own task, see below, I was overhasty.


Cleaning up what I have written (and without deep care for signs) I get

  G1 = 1/k*GAMMA(1-lambda/k,exp(-k*t)) for the first integral.


For G2 := Int(exp(-(lambda+k)*t-exp(-k*t))*G1,t = -infinity .. infinity)
I change by x=ln(1/y) and abbreviate k=lambda/a to get the following:

G2 = a^2/lambda^2 * Int(GAMMA(1-a,y)*y^a*exp(-y),y = 0 .. infinity).

This is a kind of Gamma-Distribution, but with incomplete Gamma.

Luckily there is Gradsteyn & Ryzhik, Entry 6.455.1 (*):

  Int(GAMMA(nu,alpha*x)*x^(mu-1)*exp(-beta*x), x=0 .. infinity) =

    alpha^mu*GAMMA(mu+nu)/(mu*(alpha+beta)^(mu+nu)) *
    hypergeom([1, mu+nu],[mu+1], beta/(alpha+beta));

Use Maple to find the correct parameters:

  GAMMA(nu, alpha*x)*x^(mu-1)*exp(-beta*x);
  match(GAMMA(1-a,x)*x^a*exp(-x) =%, {x}, 's'); 
  pars:=s;
 
        pars := {alpha = 1, beta = 1, mu = a + 1, nu = 1 - a}

Using that one gets 1/lambda^2*a^2*(a*LerchPhi(-1,1,a)-1/2) and finally

  G2 = -1/(2*k^2) + lambda*LerchPhi(-1,1,lambda/k)/k^3

     = -1/(2*k^2) + hypergeom([1, lambda/k],[lambda/k+1],-1)/k^2


(*) conditions [0 < Re(alpha+beta), 0 < Re(beta), 0 < Re(mu+nu) ]
are satisfied, if you feed the parameters by eval(%, pars).