Here is a solution, based on iterating through the related binary trees - see https://en.wikipedia.org/wiki/Catalan_number

>  Consider a regular polygon with  vertices. We want all non-crossing triangulations of the vertices, see https://en.wikipedia.org/wiki/Catalan_number  These are in 1:1 correspondence with the binary trees with  leaves or  internal nodes, or with  deep nested parentheses. Consider the example of a pentagon. >  >  The edges of the pentagon are labelled A,B,C,D,1. 1 corresponds to the first level vertex of the binary tree, and the others to the leaves. Edges 2..n will be internal edges added, which correspond to the internal vertices of the binary tree. >  The P representation (see ?Iterator:-Trees) for binary trees/nested parentheses gives the internal tree vertices, which are interspersed with the leafs to give a nested parentheses representation, e.g. [1,3,2] means A 1 B 3 C 2 D or  A1((B3C)2D) or just A((BC)D), where the 3 indicates the first pairing and 2 the second and 1 the last. Starting with 3, we generate internal edge 3 as the third side of the triangle B3C, then internal edge 2 is the third side of the triangle 32D, then the last triangle is 21A >  The following (inelegant and inefficient) code triangulates this case, contracting the parentheses in turn >  plist := convert(p, list); edgelist := leaves; for i from n by -1 to 2 do     member(i, plist, 'j');     print(i, j);     newedge := symmdiff(edgelist[j], edgelist[j + 1]);     AddEdge(G, newedge);     edgelist := [edgelist[1 .. j - 1][], newedge, edgelist[j + 2 .. -1][]];     plist := subsop(j = NULL, plist); end do; >  So here is a procedure that iterates though all cases >  triangulations:=proc(m::posint)   local n,leaves,edges,i,t,j,G,T,p,plist,newedge,graphs,edgelist,ng;   uses GraphTheory;   n:=m-2;   leaves := [seq({i, i + 1}, i = 1 .. m - 1)];   edges := {leaves[], {1, m}};   T:=Iterator:-BinaryTrees(n);   graphs:=table();   ng:=0;   for t in T do     G := Graph(convert(edges, set));     p := Iterator:-Trees:-Convert(t, 'LR', 'P');     plist := convert(p, list);     edgelist := leaves;     for i from n by -1 to 2 do       member(i, plist, 'j');       newedge := symmdiff(edgelist[j], edgelist[j + 1]);       AddEdge(G, newedge);       edgelist := [edgelist[1 .. j - 1][], newedge, edgelist[j + 2 .. -1][]];       plist := subsop(j = NULL, plist);     end do;     ng:=ng+1;     graphs[ng]:=copy(G);   end do;   convert(graphs,list); end proc: And here are the 14 cases for m=6 >          >

Download Catalan.mw

Does work in 2-D

sequenceoperation.mw

Well that paper (published here) just deals with many special cases, which are straightforward, but tedious, to program in Maple. For example, here is the algorithm for quintics (I didn't deal with the cases with linear factors).

Download GaloisAlgorithm.mw

ListTools:-Categorize is the easiest way to do this.

Download Categorize.mw

Since text files are sequential and not random access, I think you have to live with this inefficiency, and just read and discard the first lines, say

filnam:=cat(currentdir(),"/graph8c.txt");
to 199 while readline(filnam) <> 0 do end do:
for i to 101 while (gr[i]:=readline(filnam))<>0 do end do:

and then ConvertGraph to get them in Maple Graph form. (The end of file conditions should probably be better handled here.)

You could read the whole file in at once with readdata or FileTools:-Text:-ReadFile if memory isn't a limitation.

I'd use map here:

map(x->`if`(x<0.2,0,x),a);

The index=real[2] is the problem. If this is changed to a regular index (index=1 in this case), then Minpoly works as expected.

Download minpoly.mw

It is a sum over the different roots. Perhaps there is an easier way, but here is one way to do it.

Download simplify.mw

Your code contains the line

S2 := t -> piecewise(xn(t) <= xa and 0 < zn(t), -S1(t)*exp(mu1*alpha2(t)), 0)

which suggests that the drop-off might be when xn(t) or zn(t) becomes zero. Plotting xn(t) or equivalently, Xn, shows that Xn goes through zero at that point. So then fsolve(Xn, 0.2..0.9) returns the drop-off point of 0.5006805969.

min_problem.mw

Use Pi and not pi.

Download Pi.mw

A bit less efficient, perhaps.

[Edit: my interpretation of the OPs question was that different columns were to be scaled differently, but if rows were intended, then premultiplication by the diagonal matrix works.]

Download div.mw

If I understand correctly what you want, a (Tabulated) DataFrame is one way to display this.

stiffnessmatrixcal.mw

Here's one way to do it, using custom tickmarks.

Download dualaxes.mw

Suggest you upload your worksheet next time (green up arrow in the editor).

in
for n to N do

subs([seq(x(i) = x[c][i], i = 0 .. n),

the i in x[c][i] must be x[c][i+1] since list indices start at 1. Same for further on in the line. After fixing this there is another error arising because you have used "x" as a simple variable in the differentiation and other places as well as with x[c][i] - you need different names for these. 

There are various technical issues here that I'm going to ignore. What answer were you expecting? What do you want to happen for negative x? Is this a signal that is zero for x<0. If so, then you can just use laplace with s=I*omega

eval(laplace(f(x),x,s),s=I*omega);

gives
 1/2*Pi^(1/2)/(I*omega)^(3/2)