Diff(5,x):  % = value(%);

Is that good enough?

Note that the last two substitutions cannot be ranked by complexity because the second-to-last has an extra minus sign. These two need to be applied together. This takes about 20 seconds. Then the first eight substitutions can be applied sequentially. This happens almost immediately, and the result is completely substituted and simplified.

For some reason I can't upload the worksheet for display, but it is attached below. 

Download ans_ss.mw

Here's how to use `if` in a plot command. Note that `if` is in single back quotes (accents graves). Also note that there are no parentheses required for your expression.

expr:=
     21430.800231 - x*359.016725 - x/y*389.223603 +
     x*x/y*6.487414 + 118.7333*0.109468
:
plot3d(
     subs(_E= expr, `if`(x/y > 59, undefined, _E)), x= 53..70, y= 1..1.3,
     grid= [20,20], axes= boxed
);

I can't see your commands, but your output is weird: You should never have cos in an algebraic expression not followed by parentheses. And what does fp mean? You may need to do a restart. Here's what I get:

It could still be simplified a bit, IMO, but it is very difficult to get Maple to do more.

Download diff.mw

It is normal for some of the parameters to hypergeom to be the empty list [].

Your answer in this case can be converted to another form:

convert(%,  StandardFunctions);

will convert it to a representation in terms of BesselI and GAMMA functions.

Also, restart must be spelled in all lowercase letters; Restart does nothing.

Addressing your other question, your code contains these lines:

 eval(J, [seq](y[k]= Y[k], k= 1/2..3, 1/2)),       
 <eval(K, [seq](y[k]= Y[k], k= 1/2..3, 1/2))>

But Y is a Vector, so it can only be indexed by positive integers, 1..6 in this case. So you can change that to

 eval(J, [seq](y[k]= Y[2*k], k= 1/2..3, 1/2)),
 <eval(K, [seq](y[k]= Y[2*k], k= 1/2..3, 1/2))>

Your next problem is that K has not been defined. I think that you meant M.

Addressing your question about formatting the output of fsolve, it can be done like this:

vars:= x,y:
e||(1..2):= 'randpoly([vars])' $ 2:
eval(<vars>, fsolve({e||(1..2)}, {vars}));
          

dsolve((D@@2)(y)(x) + 4*y(x) = sin(2*x));

What you are trying to do is possible, but it would probably be easier to use the view option, which essentially cuts away parts of the plot after the fact. For example,

plot3d(x^2+y^2, x= -1..1, y= -1..1, view= [0..1, 0..1, 0..1]);

However, if the region that you want to show is not rectilinear, then you may need to do something with if. It would help if I could see your code.

L:= [seq([n, parse(cat(ListTools:-Reverse(convert(n, base, 7))[]))/n], n= 1..3000)]:
map2(op, 1, select(x-> x[2]=2, L));

I have no proof that there are none larger, but the following plot is rather convincing.

plot(L);

This is a kludgy workaround, but it may be the best possible. You have to use the prefix form of if for this to work.

You also have to use eval(subs(...)) to evaluate it; two-argument eval won't work.

Download if_sum.mw

The answer can't be determined from the given diagram. The top triangle is not necessarily right. What appears to be a rectangle may actually be a trapezoid.

If you can't see the Matrix (which will happen if it is too large), then issue the command

interface(rtablesize= infinity);

before the Matrix command.

Download table.mw

Excellent question!

First: This has nothing to do with your problem, but you should get rid of with(linalg). You are not using that package anyway, and it is deprecated (not intended to be used in new code).

The key to your problem is to never assign values to the Vector b's symbolic variables, h, y[0], and z[0] in this case. Rather, assign values to different variables and use eval to put them into b. Please let me know if you can understand the following example:

Download evalVector.mw

Please let me know if you have any trouble understanding the example or applying it to your situation.

Generating the Cartesian product of lists (all tuples) is discussed extensively in this post from 2007. Note that if (b+1)^n is large, say greater than 10 million, you may be better off using an iterator, i.e., generating the tuples one at a time rather than all at once (see ?combinat,cartprod ). The cut-off point for using an iterator depends on how much memory you can devote to storing the tuples. If you need help with an iterator, let me know. AFAIK, there is no benefit to using an iterator if you have the memory to do it non-iteratively, because iterators take significantly more processor time.

To generate them all at once, the best of the procedures from the thread mentioned above is this absolute gem of compact self-modifying code by Joe Riel:

CartProdSeq:= proc(L::seq(list))
local Seq,i,j;
option `Copyright (C) 2007, Joseph Riel. All rights reserved.`;
     eval([subs(Seq= seq, foldl(Seq, [cat(i, 1..nargs)], seq(cat(i,j)= L[j], j= nargs..1, -1)))])
end proc:

To use it with the parameters that you specified:

CartProdSeq([$0..b] $ n);