Indexed notation like cov[x]:=newval; would be the usual way to modify an entry. I don't see anything wrong with your code; I'd use eval(cov) over op(cov) for the return value for a slight improvement in readability. To reset a table, just set it to a new blank table: cov:=table();

In Maple 2023, cov := table([seq(x = x, x = X)]) could be cov := table(X =~ X)

and cov := table([seq(x = NULL, x = X)]) could be cov:=table(X =~ NULL)

Negative values (as opposed to index=negative value) are just estimates of roots. index and allvalues work best for polynomials. I do it also by fsolve, by you can also use NextZero for systematically finding roots.

I don't know another way to add "index=number", other than convert(r1,RootOf,form=index) which gives index=1 (for a polynomial).

Download RootOf.mw

In future it would be helpful if you uploaded your worksheet with the green up-arrow in the Mapleprimes editor. One problem is that your code shows diff*(S(t), t) not diff(S(t), t) because you have a space between diff and (, which is interpreted as multiplication. (also in other places).

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