Since your worksheet is long, I stopped reading after I found the first mistake. So, I don't know if this mistake is the ultimate cause of your issue. Correct the mistake, and if you still have your issue, then repost the corrected worksheet, and I'll have another look. (And if you don't still have the issue, please post a followup and say so!)

The mistake is that at one point you mispelled unapply as unpply. It's when you're defining I[Lm2] almost halfway through the worksheet.

You have three problems. The first is a trivial typo. Before the fprintf, you have a "*" which should be a ";". The second is that solve returns multiple solutions, some of which are not real. Your formatting is expecting a single real value. To get a single real value, use fsolve instead of solve (in both cases). The third problem is that with your current settings, each loop is going to execute 3 million times. Do you really want to spend the time required for that? If not, then you either need to reduce the 81920 or increase the value of dtt.

Download 1stMapleCalcI.mw

The desired expansion is not true for general A and B. (Consider A = B = -1, a = 1/2.) It is necessary to assume that they are positive. The sign of a doesn't matter.

Here are three ways:

expand((A*B)^a) assuming A>0, B>0;

expand((A*B)^a) assuming positive;

simplify((A*B)^a, symbolic);

[Edit: I completely redid this Answer, using all the original variable names, minus the underscores.]

There is a unique solution to your system. To reduce the visual space needed to present the solution, I removed the underscores from all of your names.

To be completely rigorous, we need to show that there is at least one assignment of numeric values to the coefficients that makes the denominator non-zero. This is of course trivial to do, and I leave it to you.

Download 16eqns.mw

First, you do not need to check the type of x,y,z; they are definitely integer. To find a subset of L with the desired property, we use the combinat package to iterate through subsets of L of size 4. For each subset, we iterate through its subsets of size 3, using geom3d:-IsRightTriangle. The last value of P4 after executing the loop below is your desired group of 4 with no right triangles.

C:= combinat:-firstcomb(nops(L), 4):
while C <> combinat:-lastcomb(nops(L), 4) do
     P4:= L[[C[]]]:
     ct:= 0; #count non rt triangles for this group of 4 pts.
     for P3 in combinat:-choose(P4,3) do
          geom3d:-triangle(
               ABC, 
               [seq](geom3d:-point(A||k, P3[k][]), k= 1..3)
          );
          if geom3d:-IsRightTriangle(ABC) then  break  end if;
          ct:= ct+1
     end do;
     # 4 triangles can be made from 4 pts: C(4,3) = 4.
     if ct = 4 then  break  end if; 
     C:= combinat:-nextcomb(C, nops(L))
end do:

P4;
      [[-5, 0, 2], [-5, 0, 10], [-4, -2, 3], [-4, -2, 9]]

In your Optimization command (e.g., Minimize, LPSolve) include the option output= solutionmodule:

SM:= Optimization:-Minimize(
     -4*x-5*y,
     {6 >= x+2*y, 20 >= 5*x+4*y, x >= 0, y >= 0},
     output= solutionmodule
):

Now SM is a module, so its contents (aka members) can be accessed with the :- operator. There are two members, SM:-Settings and SM:-Results. What you want is

SM:-Results(iterations);

See ?Optimization,General,Solution

You should forget about the print command. It is the wrong paradigm. It is inhibiting your understanding. Good Maple code very rarely uses it. I say this having read all your previous questions. The better paradigm is to make the result that you want to see the same as the result of the most recently executed command.

The result that you want in the present case can be achieved thus (the linebreak issue is handled automatically by the GUI) :

restart: 
a:= 2:  b:= .29:  d:= 1.85: 
eq1:= x*(-b*x^2-x+1):
eq2:= y*((a*x*x)/(b*y^2)-d-h*y): 
h:= .5: for k while 1 >= h do 
     h:= h + .1;     
     S:= solve({eq1, eq2}, {x, y});
     X[k],Y[k]:= eval([x,y], S[2])[]
end do:
convert(X, list); convert(Y,list);

   [0.809816975292943, 0.809816975292943, 0.809816975292943, 
    0.809816975292943, 0.809816975292943, 0.809816975292943]

    [1.30989205371406, 1.28289831180836, 1.25827763787148, 
      1.23567070473363, 1.21479304855971, 1.19541568678247]

You may have an old worksheet. If you have the 32-bit version of Maple, then you have the Classic interface. Use that to open the worksheet. Then resave it. Then try again with Standard. If you have 64-bit, then post the worksheet, and I'll do it for you.

Two (of many) ways:

A:= t-> [a(t), b(t), c(t)]; #a list

A:= t->  < a(t), b(t), c(t) >; #a (column) vector

To prove that two algebraic numbers A and B are equal, use

evala(Normal(A-B));

You will get 0 if and only if they are equal.

In your case, they are equal. In this case simplify(A-B) will also work; however, the evala technique is guaranteed to work whereas the simplify is not.

The question remains, How can the first form be simplified to something like the second form? One technique that works in this case is identify.

r:= evalf(A):
for d from Digits+1 to 2^13 while r::float do
     r:= identify(evalf[d](A));
end do:
d-1, r;

This is only a guess (albeit a very sophisticated guess), and it still needs to be proven:

eval(Normal(A-r));

                               0
 

Here is a version that I've reworked to make use of parallel processing. I needed to increase the number of side vectors b to 2^12 in order to get a meaningful time measurement. If your number of side vectors is only about 100 (like you said), it will be extremely wasteful to use the code below. This is because the overhead involved in setting up the parallel processing will be far greater than the time to solve the problem on one processor.

Download ParallelModular.mw

At the sizes that you are talking about, it is not worth using multiple parallel processors. The following solution command runs in time less than the smallest time that can be measured directly by Maple, which is 1/64 seconds. If you really want to run on multiple parallel processors, let me know. But I think that the overhead of initiating the processes would outweigh any time savings.

Here's an example.

Download ModularSolve.mw

It can be done with a single plot command. No transform or display is needed.

restart:
V:= exp(-x)*y^3/eta^3:
eta:= 1+k*x+sin(2*Pi*x):
x:= 0.1:
Ks:= [.1, .5, -.1]:
plot(
     [seq](eval([V, y, y= 0..eta], k= K), K= Ks),
     labels= ["v", "y"],
     color= [black, red, blue],
     linestyle= [solid, dash, dot],
     legend= [seq](k = K, K= Ks)
);

It is sad that you have not received more help.... I can give you a tiny bit of help, but I have very little knowledge of this subject area. I think that some of what you want can be done with the ?DynamicSystems package. In particular, there is ?DynamicSystems,BodePlot and ?DynamicSystems,TransferFunction .

I think that Joe Riel may know this package well. Maybe he will notice this namecheck and respond.

Also, could you please retype your expressions in normal characters? The Maple Math typesetting is horrible---nearly impossible to read.