This is obviously a Question, not a Post. It was a Question when I first saw it. I don't know why someone converted it to a Post.

@smithss This new problem is so much larger than the first that it's utterly inconceivable that it could be solved by Kitonum's method even on the largest and fastest computer in the world. The problem is that his method first generates all the permutations, then it checks them. The highest-capacity solid-state drive (SSD) on the market is 100 Terabytes (10^14 bytes). Even if we used an efficient encoding scheme (4 bits per entry), it would take 600,000 of those drives to store all the permutations. If it's solvable at all, then you must use iterative methods. The command is Iterator:-Permute. 

@Joe Riel It's ridiculous that one needs to declare _self at all. It's akin to declaring _params, thisproc, thismodule, etc.

@Christian Wolinski You wrote (well after I posted the above Answer):

• Often I lose sessions because STOP button does not accomplish.

You're either ignoring my Answer above, or you don't understand it, or both. If you use your operating system to kill the kernel, then the following things will happen:

• You'll get a pop-up message about a "lost kernel connection". Nearly everything written in that message is either misleading or flat-out wrong. In particular, you don't need to close your Maple session. It's as if that message was written by a legal department or marketing department rather than by someone who actually knows anything about Maple.
• After dismissing that pop-up, you'll be able to save your worksheet exactly as it was at the instant that the kernel was killed (instead of as it was at the most-recent auto-save).
• The above is true regardless of whether you have the auto-save feature turned on.
• Once you're familiar with the steps (find, kill, dismiss, save, exit (worksheet, not session), re-open), this process is often faster than using the STOP button.

@Kitonum I'm amazed that a solution can be found in reasonable time by that method because there are 

(9!/(3!*2!*2!))^6;
                   11948427342082473984000000

(approximately 10^25 or 10 septtillion) possible permutations. I wonder roughly what proportion of them are solutions?

@JAMET When using 2D Input, you cannot put a space (or other whitespace, such as a line break) between a procedure/command name and the left parenthesis that begins its arguments. Those spaces will be interpreted as multiplication. 

@Christian Wolinski The commands ilog2 and ilog[2] do the same thing for integer input, but ilog2 is builtin (to the kernel) and is extremely fast.

@JAMET There's nothing wrong with Tom's version, but here are the text labels in my customary style:

restart:
theta:= 2*Pi/17:
P:= [cos,sin]~([$0..16]*~theta):
plots:-display(
    plot(P, style= point, symbol= solidcircle, color= red, symbolsize= 10),
    plots:-textplot([seq]([(1.15*P[k])[], cat("M", k)], k= 1..17)),
    gridlines= false, axes= boxed, view= [(-1.3..1.3)$2]
);

If you'd read your own posts after posting them, then you'd see that your images (which presumably show some mathematical formulae) are not coming through, so readers are confused by your references to an "image". Surely these formulae for the linear transformation aren't so complicated that you couldn't simply type them here. You typed them into Maple, right? You can use the green uparrow on the toolbar of the MaplePrimes editor to upload your Maple worksheet.

@lcz Vertices can be referred to by their labels or by their indices. The command VL:= Vertices(...) returns the list of vertex labels. The index of the vertex labeled v is the positive integer j such that VL[j] = v. It is often the case that the vertex labels and the vertex indices are identical.

It's usually more efficient to work with the indices. The two representations are usually not interchangeable. Obviously, the adjacency matrix is indexed by the vertex indices.

Although I'm not very familiar with this topic, my guess is that you're more likely to find what you need in Maple's SignalProcessing package than in its inttrans package.

What's so bad about "having to type the equations manually into fsolve"? You need to somehow get the equations into Maple. It's also possible to send input to Maple via photo through Maple Calculator.

Rouben,

The title of this Question is precisely the example title given on the MaplePrimes "Ask a Question" form. I guess the OP's knowledge of English is such that that was the only title that they could come up with.

@ijuptilk You asked:

• Is it possible to have an array or list of u without defining u in the proc(xi) ?

Yes, it's easy, and commonly done. It's probably better to use a list rather than an array. You should make u a parameter of doCalc, like you originally had, something like this:

doCalc:= proc(xi, u::list(numeric))

And you can call it as (for example)

doCalc(3, [seq](0..20, 1))

@Hullzie16 You wrote:

• When we are telling maple that the discirminant is positive we are saying three real roots, but when doing what you described it only returns one, When it should be returning three. 

I get this:

restart;
f:= 2*y^3*z - y^2 - 2*m:
sols:= solve({f=0, discrim(f,y)>0, m<0, z>0}, {y}, parametric, real);
[[y = RootOf(2*_Z^3*z - _Z^2 - 2*m, index = real[1])], [y = RootOf(2*_Z^3*z - _Z^2 - 2*m, index = real[2])], [y = RootOf(2*_Z^3*z - _Z^2 - 2*m, index = real[3])]],  And(And(0 < z, -1/(54*z^2) < m), m < 0)

(For copy-and-paste to MaplePrimes, I've omitted the irrelevant "otherwise" branch of the piecewise, but it does appear in the worksheet display.) Notice the second arguments of the three RootOfs: index= real[...]. That's explicitly saying that there are three real roots. I know that you already know that; I'm pointing it out because it shows that Maple also knows it.

• Is the explanation similar to what I above and that there is always imaginry contributions?

Essentially, yes, although I wouldn't exactly call them "imaginary contributions". Rather, I'd say that it's often impossible to express the real roots as algebraic functions of the parameters without using I or sqrt(-1) or something equivalent. I'm using "algebraic function" here in its usual mathematical definition (the complement of transcendental function) rather than as Maple's type algebraic, which is much broader (compare help pages ?type,algebraic, ?type,algfun, ?Definition,algebraic). As @dharr explained, you can often get Maple to express them as trigonometric (transcendental) functions with no I. My opinion is that the RootOf form is the best, most-general, and usually most-compact way to express them.