You're not ruining my vacation. I love nothing more than showing people how to use my LogicProblem package, and I only worked on these at night when there wasn't anything local to do. Besides, I did most of this one while waiting for my flight in the San Jose, Costa Rica airport.

You made two mistakes in coding this problem (the "Meet the Challenge" or "Book Swap" problem). The first is that you need to make the surnames a separate variable. The second is that all of the constants' names need to be unique. So, even though the books brought are the same as the books borrowed, I make the names distinct by prepending br_ or bo_.

After defining the variables and constants thus, all of the constraints except #20 are straightforward equalities. #20 needs to be specified in a procedural form accepted by the package. I too tired right now to explain in detail how these procedures work, but I urge you to read my comments to the code of the package, especially the long comment preceding procedure `Know/Proc`.

Please make a separate thread for each new logic problem.

Download BookSwap_LP.mw

If you try to pass a sequence to convert it mistakes that as mulitple arguments, which it doesn't know how to handle. It is easier to work with lists than sequences.

a:= [seq(taylor(cos(x),x=0,i),i=[2,4,6])]:
convert(a, polynom);

The soccer problem is very easy with my LogicProblem package because all of the constraints translate directly to equalities and inequalities.  Your file did not attach, so I can't see what you did wrong.

Download Soccer_LP.mw

I can't reproduce your problem, so I am not sure this will fix it. In procedure `*`, you should refer to global `*` as :-`*`. You should also make i local.

m:= module() option package; export `*`;
    `*`:= proc( a::list, b::list) option overload;
     local i;
        return add(i, i  in zip(:-`*`, a, b));
    end proc;    
end module;

Let me know if that helps. And if you can get a reproducible example of the problem, please post it.

Your data are too large. Try scaling down by a factor of 1000.

F1 := Vector([1500, 1750, 2250, 4000, 4300, 5000, 7000]):
Statistics:-MaximumLikelihoodEstimate(Weibull(beta, eta), F1 /~ 1000);

Weibull has a linear scaling property for the first parameter, so the answer using your original data is

applyop(x-> 1000*x, [1,2], %);

I used solve to solve the resulting n^2 x n^2 system of linear equations. There may be a more-efficient method.

restart:

The procedure:
Solve:= proc(A::Matrix(square), B::Matrix(square), C::Matrix(square))
# Solves matrix equation A.X + X.B = C for X.
local
     i, j, x,
     X:= Matrix(rtable_dims(A), symbol= x),
     xs:= {seq(seq(x[i,j], j= rtable_dims(X)[2]), i= rtable_dims(X)[1])}
;
     if [rtable_dims(A)] <> [rtable_dims(B)] or [rtable_dims(B)] <> [rtable_dims(C)] then
          error "Incompatible matrix dimensions"
     end if;
     eval(X, solve(convert(A.X+X.B =~ C, set), xs));
end proc:

Example of use:
(A,B,C):= ('LinearAlgebra:-RandomMatrix(3,3)' $ 3);

x:= Solve(A,B,C);

Verification:
A.x + x.B;

LinearAlgebra:-Equal(%, C);      

                                       true

Download Matrix_equation.mw

restart:
5*sqrt(1-sb^2) = 6*sqrt(1-sb^2)*sa*sqrt(1-sa^2)+4*sb,
42*sqrt(1-sa^2) = 3*sqrt(1-sa^2)*sb*sqrt(1-sb^2)+4*sa:
fsolve({%}, {sa=.995, sb=.743});

Next time, please post your equations in plaintext form so that I do not need to type them in.

There is a huge variety of nonsensical input that you can give to Maple for which it does not issue an error message. Don't try to ascribe meaning to the output. (There is an old saying of computer science: GIGO---Garbage In, Garbage Out.) As far as I know, there is never a reason to give FAIL as input. See ?FAIL and ?boolean .

According to the technical definitions of bug and feature, a situation which is not described in a program's documentation cannot be considered as either one. A bug is a situation where a program acts contrary to its documentation; a feature is a useful situation where a program acts in accordance with its documentation.

There are two steps to convert a list of points into piecewise form. First, apply the procedure JoggedLine (which can be found in this post by Kitonum, the procedure's author) to the list of points. This will give you an expression in absolute value form. Then apply convert(..., piecewise) to that expression. Example:

JoggedLine([[0,2],[3,-2],[7,6]]);

convert(%, piecewise);

Adri's Answer suffers from a common flaw in Maple code: It builds a sequence or list by iteratively appending each new element onto the end of an existing sequence or list. This is very inefficient in Maple because on each iteration it creates a new sequence or list. Thus the time complexity of this operation is O(n^2) where n is the number of items in the sequence or list.

There are two main alternatives: (1) Build with a seq command, or (2) build using a table or dynamic Vector or Array and convert to a sequence or list as the last step. The seq option is often not possible, but it is in this case. The are also several other ways to simplify the code.

Download Array_build.mw

Download Matrix_solve.mw

You can trap the error with the try statement. Here's an example. It is not necessary to use parse; any code can come after the try. The parse statement is useful if you want to set up your 50 problems as strings of code to be evaluated.

restart:
Problems:= Vector(50, k-> sprintf("50/(25-%d)", k)):
Answers:= Vector(50):
for k to 50 do
     try
          Answers[k]:= parse(Problems[k])
     catch:
          Answers[k]:= sprintf("k = %d: %s", k, lasterror);
          print('k'= k, "Error found")
     end try
end do;

Answers[25];

"k = 25: numeric exception: division by zero"

Answers[50];

−2

See ?try .

For your second question T(..., ...) is called "programmer indexing". See ?rtable_indexing .

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