How about

(T-> (p-> [T[..-2][], p])~(combinat:-permute(T[-1])[..max(2,nops(T[-1])!)/2])[])~(Tours);

But, there must be a better way to your overall goal. If you describe that goal better, maybe I can figure out a better way.

min({L[ ]} minus {0});

I think that you're having a problem that the other respondents aren't because you're saving the module to a library and they aren't. Global variables aren't part of the module and thus won't be saved unless they are explicitly mentioned. There is no need for global variables. Try this:

MonPackageFonctions:= module()
option package;
local GeometricData, r, l, ModuleLoad:= ()-> SetGeometricData(0.2, 1);
export 
   GammaNum:= xx->
      evalf(eval(Pi-arccos((-xx^2+l^2-r^2)/xx/r/2), GeometricData)),
   psiNum:= xx->
      evalf(
         eval(
            -arcsin(sqrt(-(xx^4-2*xx^2*l^2-2*xx^2*r^2+l^4-2*l^2*r^2+r^4)/xx^2/r^2)/2/xx/l),
            GeometricData
         )
      ),
   SetGeometricData:= proc(r::algebraic, l::algebraic)
      GeometricData:= [thismodule:-r= r, thismodule:-l= l];
      NULL
   end proc
;
   ModuleLoad()
end module:

This exports a procedure that lets you set the GeometricData externally but also uses r= 0.2 and l=1 as defaults.

If the file is named myfile.bat then do

system("myfile.bat");

There are many possibilities. The criteria are mostly aesthetic. How about this?
 

Download Tours.mw

In differential equations in Maple, the dependent variables must always be used in functional form, i.e., x(t) and y(t) rather than x and y. Therefore, your code should be changed to

with(inttrans);
eq5 := diff(x(t), t)+diff(y(t), t$2) = 5*exp(2*t);
eq5s := laplace(%, t, s);
eq6 := diff(x(t), t)-x(t)-(diff(y(t), t))+y(t) = 8*exp(2*t);
eq6s := laplace(%, t, s);
solve({eq5s, eq6s}, {laplace(x(t), t, s), laplace(y(t), t, s)});
subs({x(0) = 2, y(0) = 1, (D(y))(0) = 1}, %);
eq3 := invlaplace(%, s, t);

If you make this simple change, then the last line will give you the answer that you're looking for.

A more-sophisticated approach---which might be useful if you want to re-use this operation a lot---is to use the RandomTools package:

RandomTools:-AddFlavor(
   A = module()
   local r:= rand(-90..90);
   export Main:= ()-> (a-> [a, convert(a*degrees, radians)])(r());
   end module
):
randomize():
n:= 4:
RandomTools:-Generate(list(A, n));

P:= [$2..5]:
Tours:= combinat:-setpartition(P):
nops~(Tours);
([1,op]~)~(Tours);

Your equation is an ODE with a parameter, y; it is not really a PDE because there are no derivatives with respect to y. So, it can be solved with dsolve:

restart:
equa1:= diff(u(x), x, x) - y*(1+x):
dsolve({equa1, u(0)=0, D(u)(0)=0});

You can use continued fraction convergents, like this:

Download Continued_fraction_convergents.mw

If your version of Maple is too old to have the NumberTheory package, then exactly the same thing is available in the numtheory package as commands cfrac and nthconver.

You can apply simplify to nested piecewise to convert it to a one-level piecewise:

simplify(m);

eval([x,y,z], L);

Careful, that must be [x,y,z] rather than {x,y,z} lest it won't be an ordered triple.

0.3*(1 - 0.4*0.5) = 24%

It is not clear to me that the OP is interested in distinguishing between trees whose underlying graphs are isomorphic. This is often the treatment of the subject in an undergraduate mathematics course titled "graph theory" or "discrete mathematics", where a tree is defined simply as a connected undirected graph with no cycles. Using that definition, a representative of each isomorphism class of trees of order 7 can be displayed in a single row using

plots:-display(
   GraphTheory:-DrawGraph~(
      <GraphTheory:-NonIsomorphicGraphs(
         7, 6, output= graphs, outputform= graph, restrictto= connected
      )>^+
   )
);

On the other hand, if the OP does mean "trees" in the computer-science sense of rooted oriented trees, then these can be generated by the command Iterator:-OrientedForests. There are 48 of these of order 7, and they can be displayed in a 6x8 array like this:

plots:-display(
   GraphTheory:-DrawGraph~(
      Matrix(
         (6,8), 
         [seq(
            GraphTheory:-Graph({seq({k,V[k]}, k= 1..numelems(V))}),
            V= Iterator:-OrientedForests(6) #6 = 7 nodes - 1
         )]
      ), style= tree, root= 0
   )
);

Unfortunuately, neither of these solutions will work in the OP's claimed version, Maple 12.

Download Int_of_sech_power.mw