First, get rid of with(linalg). Then replace these old linalg commands

with the single command

Solution:= LinearSolve(A, XY):

Then you can plot the exact and the approximate solution together with

F:= x-> (1-x)*cos(x):
display([
     pointplot([seq]([h*(k-2), Solution[k]], k= 2..m+1), color= blue),
     plot(F(x), x= 0..1)
], symbol= diamond
);

You can plot the errors with

pointplot(
     [seq]([h*(k-2), F(h*(k-2)) - Solution[k]], k= 2..m+1),
     symbol= cross, title= "Errors"
);

You need to use lists rather than sets because you have no control over the order that things will appear in a set. Also, your indices themselves need to be lists because "naked" sequences cannot be distinct members of lists (or sets). Once you have lists, let's say A is your list of indices and B is the set of values. Then just do

A =~ B

It is possible for a naked sequence to be either or both of the sides of an equation. You can achieve this by

zip((x,y)-> op(x)=y, A, B)

zip is the two-set (or two-list) analog of map that you were looking for.

Example:

A:= [[1,2], [3,4]]:
B:= [5,6]:
zip((x,y)-> op(x)=y, A,B);
                    [(1, 2) = 5, (3, 4) = 6]

There is no effective way to make such an assumption. Even if you were include every possible inequation x[i] <> x[j], you would likely just overload the ability of a solver. That's why Combinatorial Optimization and Constraint Satisfaction Problems are their own areas of study, distinct from, for example, Linear Programming.

But you can solve such an equation by cycling through all permutations if the number is not too great. In the case at hand, we have 9! ~ 300,000---reasonable. The following executes in 0.235 secs for me.

restart:
eq:= a[9] = add(a[2*k-1]/a[2*k], k= 1..4):
A:= combinat:-firstperm(9):
while not evalb(eval(eq, a= A)) do  A:= combinat:-nextperm(A)  od:
eval(eq, a= ``~(A));

I tried in both Maple 16 and 17, and I cannot duplicate your results; I get relatively smooth plots for the first and second derivative. According to ?dsolve,numeric,bvp , the maximum value of maxmesh is 2^13 = 8192. I got results at 2^10, with no difference at 2^13. I decreased abserr to 1e-7 (default is 1e-6) and increased Digits to 20, and I got no difference. Here are my plots. Note that the range is 0..1.

for k from 0 to 2 do
     odeplot(sol, [x, diff(Urn(x), [x$k])], 0..1, numpoints= 1000)
end do;

You wrote:

Also, the list with the output does not show the 2nd derivative of Uthetan, the 4th derivative of Urn and the 2nd derivative of Uxn. They are in the equations... is that a problem?

It is not a problem. It never includes the highest-order derivative of any of the functions. If you want to plot those derivatives, there are several workarounds.

I tried in both Maple 16 & 17, obtaining the same results. The "hang" occurs in simplify. I don't know whether it is an infinite loop, or just an expression that is too complicated for simplify. Since the expression fits on one line on my screen, the latter seems unlikely. Running with infolevel[simplify]:= 5, the only information is a seemingly endless repetition of

• simplify/do: applying  commonpow  function to expression
• simplify/do: applying   power  function to expression

The hang will occur for any of z[17], z[18], z[19], z[20]. It does not matter whether the expand or factor or both are applied before the simplify. Only the first two solutions need to be substituted in for the hang to occur. So here is one of the seemingly simple expressions for which it hangs:

subs(solution1, solution2, z[20]);

lprint(%);

0 = -(-b4*f8+b8*f4)*conjugate(f7)*d5*(conjugate(b4)*conjugate(d8)-conjugate(b8)*conjugate(d4))/((a4*b8-a8*b4)*(conjugate(a4*b8)-conjugate(a8*b4)))-(-a4*f8+a8*f4)*conjugate(f7)*d5*(conjugate(a4)*conjugate(d8)-conjugate(a8)*conjugate(d4))/((a4*b8-a8*b4)*(conjugate(a4*b8)-conjugate(a8*b4)))+conjugate(e7)*e5

How about diff(z(t), t) = m with initial condition z(0) = n? Then the system becomes

diff(x(t), t) = -x(t) + 2*z(t)*y(t) - 2*k*z(t)^2,

diff(y(t), t) = -y(t) + k*m - z(t)*(x(t)/2 - 1),

diff(z(t), t) = m;

Here it is, by guiding Maple at each step (or "holding its hand").

Download int_sec^n.mw

You need to create an Array (or Matrix) before you can assign to it. Otherwise, the object becomes a table.

(n,m):= (3,3);

U:= Array(0..n+2, 0..m):

U[.., 0]:= < y(a), seq(f[k], k= 0..n), y(b) >;

Note that it is U[.., 0] rather than U[0, ..]. The latter would create the first row rather than the first column.

First, you must create and store S as a Vector, list, or table---not a set. There are two problems with using a set:

1. Duplicate entries are eliminated, and in your case there is a small chance that two of the numbers associated with an index pair are the same.
2. A set is stored sorted, and you'll want to avoid the super-linear overhead of the sort.

Which one is the most efficient to use---Vector, list, or table---depends entirely on the code used to create S. So, I'd like to see that code. Note that if you use a table, then the sum can be accumulated as the entries are created. Create it with table(sparse) so that entries are initialized to 0.

The process of converting S to a Matrix is independent of which of the three formats that you use. I will assume that the Matrix order N is known a priori; if instead the order needs to be determined from the scan of S, then my code will need to be modified.

Download sparse.mw

Because of the issue of the target lists possibly appearing as sublists, I recommend that you use strings instead of lists as your data structure. Then you can use StringTools:-SubstituteAll for the operation.

Even if you need to use lists, it may be faster to perform the operation by converting to a string and then back to a list every time. That's because the StringTools commands are written in compiled code.

First, get rid of linalg. If you need linear algebra (you don't for this bit of code), use LinearAlgebra instead.

Only the terminal punctuation of the whole for-do loop, either colon or semicolon, makes any difference in the printed output. So we need to suppress all the output by ending the loop with a colon, and, within the loop, selectively printing what we want with a print statement.

for h from .5 by .1 to 1 do
     eq1 := x*(-b*x^2-x+1);
     eq2 := y*((a*x*x)/(b*y^2)-d-h*y);
     S := solve({eq1, eq2}, {x, y});
     SS := solve(subs(S[3], {omega^4+(h*y+x)*omega^2+h^2*x-y}), {omega});
     tau := simplify(subs(S[3], subs(SS[3], (b^2*h*y+a*x)/omega)));
     print('tau' = tau);
end do:

You wrote:

what if we change the original equation to a pde with the derivative on the left hand side to a derivative with repect to t?

Then the rest of your code in your original question works. The animation shows a very interesting wave pattern. Thus I think this is what the equation was origianlly intended to be. It doesn't make sense to me to do it in 3D though.

S:= pdsolve(pde, {bc, ic}, numeric):
S:-animate(t= 0.1, frames= 64);

Your matrix is severely rank deficient, a 57x57 with rank 44. The matrix is singular. I don't think it's a problem in your program; rather, it's a problem with your initial data. You could seek a least-squares solution to the linear system. However, I know nothing about this type of engineering problem, so I don't know if that's appropriate.

You should not use the package linalg. Use LinearAlgebra instead.

By the way, this is the most primitive Maple code of its size that I have ever seen---although it is neatly presented. It's very easy to make a mistake if you initialize huge matrices by indexing each element in its own assignment statement.

You wrote:

can this function be animated in 3d?

Sure. It's very easy:

S:= pdsolve({pde, bc}):
plots:-animate(plot3d, [eval(U, S), x= 0..1, t= 0..T], T= 0..10);

This particular function makes a rather boring animation though.

Why are you using Vectors instead of lists? You can use Vectors, but for every operation of this type, you'll need to convert to a list and then back to a Vector. And possibly you'll need to convert to and from a set also.

Once you have it in list form, there are several commands in ?ListTools to help with the things that you're asking about, specifically, ?ListTools,Categorize ?ListTools,Classify ?ListTools,FindRepetitions ?ListTools,MakeUnique and ?ListTools,SearchAll