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

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.