@Christian Wolinski As Rouben said, there may have been a time when (-1)^(1/2) did not automatically simplify to I. And perhaps also sqrt(-1) at some previous time didn't return I (which isn't an automatic simplification; the code that does it can be seen on line 4 of showstat(sqrt)). These are minor points which I doubt many remember from a 20+-year-old Maple version. My first Maple version was 5.4.

The major point is that the type system (which includes the commands type and indets) does purely syntactic checking of expressions; it applies no mathematical knowledge whatsoever. It's necessary that it work that way, and that's the way it worked in Maple 5.4. So it doesn't know that I = sqrt(-1) = (-1)^(1/2) (where I'm using = in the mathematical, not Maple, sense). Nor does it know that 2 = sqrt(4)/ Would you expect type(2, posint^fraction) to return true?

Mathematical equality of different numeric expressions isn't an integral component part of "Boolean logic". If you allow the only addition, multiplication, the sine function, and one real-valued variable, it's quite easy to create equations whose truth is formally undecidable. See Richardson's Theorem.

I'd guess that you know most of this already, given your extensive experience with Maple as shown by your many good Answers here, but for some reason you're choosing to ignore it at the moment.

What type of data? Zero-one (such as adjacency matrices)? Small integer? Rational? Hardware float? Symbolic (i.e., expressions with variables)? Etc.

Your computation gives me 4.61: 

exp(-0.07*05)*0.5236*12.50;
                          4.612183547

Perhaps I don't understand $12.50. I took the $ to be a currency symbol.

Your code uses both lowercase theta and capitalized Theta. Was that your intention? They are different variables.

@MANUTTM The equations use F(z). Where is F defined?

Since there's an equation relating w and q, there's no need for a loop. The whole thing can be done with a single call to NLPSolve.

@MANUTTM Any equations or non-strict inequalities (meaning <= rather than <) can be added as constraints to the NLPSolve command. Equations are expressed with =, not := (which are assignments). I'm not sure how to interpret what you highlighted---

q := p*(2*`&Phi;s`/(w - v) - b);
`&Phi;s` := 0.5*epsilon*(1 - F(z));

---but I think they should be equations.

@MANUTTM Obviously you must generalize the loop so that all references to w, wtemp, etc., are replaced with w and y, wtemp and ytemp, etc., like this:

for lambdam in l do
    (wtemp, wnew, ytemp, ynew):= (60, 20, 50, 10);
    while 0.05 <= abs(wtemp - wnew) or 0.05 <= abs(ytemp - ynew) do
        (wtemp, ytemp):= (wnew, ynew);
        Etemp:= eval(eval(E1), [w,y]=~ [wtemp,ytemp]);
        Soln:= NLPSolve(Etemp, p= 5..500, q= 10000..30000, maximize);
        (ptemp, qtemp):= eval([p,q], Soln[2])[];
        `&pi;temp`:= Soln[1];
        Emanf:= eval(eval(E2), [p,q]=~ [ptemp,qtemp]);
        Soln:= NLPSolve(Emanf, w= 30..60, y= 5..50, maximize);
        (wnew, ynew):= eval([w,y], Soln[2])[]
    end do;
    print(lambda, ptemp, qtemp, wtemp, ytemp, `&pi;temp`)
end do:

@MANUTTM For the 4-variable problem, the correction of the final loop in very similar to the correction for the 3-variable problem with the addition of y (ytemp - ynew) to the while loop condition. However, I do not understand the difference between Q and q.

@MANUTTM To do what you described, you need to make the final loop something like this:

for lambda in l do
    (wtemp, wnew):= (100, 20);
    while 0.05 <= abs(wtemp - wnew) do
        wtemp:= wnew;
        Etemp:= eval(eval(E1(p,q)), w= wtemp);
        Soln := NLPSolve(Etemp, p= 5..500, q= 10000..30000, maximize);
        (ptemp, qtemp):= eval([p,q], Soln[2])[];
        `&pi;temp`:= Soln[1];
        Emanf:= eval(eval(M1(w)), q= qtemp);
        Soln:= NLPSolve(Emanf, w= 20..100, maximize);
        wnew:= eval(w, Soln[2])
    end do;
    print(lambda, ptemp, qtemp, wtemp, `&pi;temp`)
end do:

The problem with this is that M1(w) is a very simple function of w whose maximum will always be achieved at the upper bound of w=100.

Why did you create another username to ask the same question? That behavior won't be tolerated here.

@dharr Getting the indices of vertices does not require member and using it would be inefficient (linear search). You can do this instead: Let Vs be the list of vertices. Then do

V:= table(Vs=~ [$nops(Vs)]);

Then V[v] is the index of v. 

Getting the indices of the neighbors of v is just as easy because of an undocumented (AFAIK) structure built in to the graph representation. I'm about to write that up in an Answer.

@Agha What you describe could be done with JPEG images, but it's not the easiest or best way. Two other ways that would use far less memory and effort are

1. Find a character encoding of the star in an HTML or Unicode character set and plot with textplot.
2. Construct the star as a filled polygon and plot with plot.

@mmcdara When a function, for example f(x,y,z), is prettyprinted, Maple looks for a procedure named `print/f`. If it exists, then what is actually printed is determined by `print/f`(x,y,z).

@acer Could the 0-bytes files be a separate problem caused by MaplePrimes reaction to the Ç (C-with-cedilla) in the filename?

@zenterix Did you use backquotes (on upper left of standard keyboard) around the 0 that's used as a matrix name? Forward single quotes won't work.

The code can be made much simpler if all you want to do is display the object, not compute with it later.