The following is a hack that temporarily patches the deficiency/bug in PDEtools:-dchange that Alejandro pointed out. It gets you what you aked for: the application of dchange, but with unexpanded/unevaluated derivatives.

Download dchange_hack.mw

I have a feeling that there's a more efficient algorithm to generate a round-robin tournament schedule than what I have below. I end up throwing out 2/3 of the partitions. Hopefully a more-skilled combinatorist can comment on the efficiency. Nonetheless, it does get you the answer that you need.

Other interesting questions are:

1. How do you count how many essentially distinct round-robin tournament schedules there are?
2. Is it possible to generate them efficiently with an iterator?
3. How do the answers change when the number of teams is odd? (The code below will not work when the number of teams is odd.)

In the code below, remember to use compile= false as an option to SetPartitions if you don't have a Maple compiler.

restart:
T:= {}:
night:= 0:
for P in Iterator:-SetPartitions({A,B,C,D,E,F}, [[2,3]]) do
     p:= {P[]}:
     if p intersect T = {} then
          T:= T union p;
          night:= night+1:
          printf("\nNight %d:", night);
          for s in p do
               printf(" %a vs. %a ", s[])
          end do
      end if
end do:

Night 1: A vs. B  C vs. D  E vs. F
Night 2: A vs. C  B vs. E  D vs. F
Night 3: A vs. D  B vs. F  C vs. E
Night 4: A vs. F  B vs. C  D vs. E
Night 5: A vs. E  B vs. D  C vs. F

Solve symbolically first. Use unapply to turn the symbolic solution into a procedure with paramter a. Then map that procedure over Vector a. Doing it this way, I accomplished the entire job in 0.2 seconds.

restart:
n:= 10^4:
eq1:={b = a^2, c = b^3/2, d = c^(1/2)*4 + b^2}: #No quote marks on a!
st:= time():
Sol:= unapply(solve(eq1, {b,c,d}), a);

a:= Vector(n, i-> i):
ans:= map(Sol, a):
time()-st;
                             0.188

Download AngleBetween.mw

Let n represent the number of degrees of freedom. Then

X:= Statistics:-RandomVariable(StudentT(n)):
T:= unapply(Statistics:-CDF(X,x), n,x);

plot(T(1,x), x= -3..3);

evalf(T(1,1));
                       0.750000000000000

Please ask any further questions about logic problems in a new thread.

Here is how to obtain a complete solution to the logic problem, and to prove its uniqueness, using my LogicProblem package (available at the Maple Applications Center).

Download WhoWorksWhere.mw

You need to put the if statement inside the procedure, like this:

MARK:= (a,b,c,d)->
    if a.d-b.c = 0 then
         [0,0,0,0]
    else
         [d/(a.d-b.c), -b/(a.d-b.c), -c/(a.d-b.c), a/(a.d-b.c)]
    fi;

The print statement is not needed. Indeed, print is never an appropriate way for a procedure to return its output.

restart:
`mod/ReduceExponents`:= (p::polynom, n::posint)->
     evalindets(p, '`^`'(name, posint), T-> op(1,T)^(op(2,T) mod n)):
p:= x-> 1+x^3+x^17+x^19:
ReduceExponents(p(x)) mod 17;

ArrayInterpolation will not accept exact integer values; they must be converted to floating-point values with evalf. Also, do not use with inside a procedure; use uses instead. And I made your variables local. A will be the return value of the procedure.

InterProc := proc ()
uses CurveFitting;
local i, A, variable1, variable2;
     A := Matrix(10, 4);
     variable1 := evalf([0, 100]);
     variable2 := evalf([12, 20]);

     for i from 1 to 10 do
          A(i, 1) := evalf(3+i);
          A(i, 2) := 2*i+A(i, 1);
          A(i, 3) := A(i, 2)-1;
          A(i, 4) := ArrayInterpolation(variable1, variable2, A(i, 1));
     end do;
end proc;

Three errors I see:

1. "if" must be with a lowercase "i".
2. Need a semicolon at the end of the first line.
3. The denominators need to be in parentheses: (a*d - b*c).

You should make your code into a procedure, like below. There is no need for the print command.

Download Inverse.mw

Use the function form on input, delta(x) and Delta(x), and define the following procedures, perhaps in your initialization file:

`diff/delta`:= x-> delta(x):
`diff/Delta`:= x-> Delta(x):
`print/delta`:= x-> delta*x:
`print/Delta`:= x-> Delta*x:

Now the function form will display as the multiplication form, it won't be affected by taking the derivative, and simplify will only see the function form and won't change it.

Your first line is x:= x0. That should be x0:= x.

Then you'll have a problem because your last two break statements are not in a loop. I suggest that you change your procedure to something like this:

proc_r:= proc(x :: realcons)
local x0;
     x0:= evalf(x);

     #reducing the value to between -Pi and Pi
     while x0 > evalf(Pi) do  x0:= x0 - 2*evalf(Pi)  end do;
     while x0 < evalf(-Pi) do  x0:= x0 + 2*evalf(Pi)  end do;

     #using the symmetry of sin to reduce to between -Pi/2 and Pi/2
     if x0 > evalf(Pi/2) then  x0:= evalf(Pi) - x0
     elif x0 < evalf(-Pi/2) then  x0:= evalf(-Pi) - x0
     end if;

     return x0
end proc:

proc_r(7);  
                                   0.71681469282042

If M is your Matrix, then do

ArrayTools:-AddAlongDimension(M,2);

@Andriy Here is your file with my modifications. All I did was change q and Np from globals into parameters. Please check that this generates the correct matrix, and compare the time to sequential code on a reasonably sized example. The Grid option will no doubt take longer on an example that is too small.

MatrElems_Carl1.mw

plot([cosh(x), x^2], x= -2..2);
f:= x-> x^2:
r:= fsolve(cosh(x)=x^2, x);
[r, f(r)], [-r, f(-r)];