Sin:= unapply(subs(infinity= n-1, convert(sin(x), FormalPowerSeries)), [x,n]);

plot(Sin(x,20), x= -2*Pi..2*Pi);

Yes, plots:-arrow (not plottools:-arrow) is the answer. Here's a procedure to do what you want. Any optional arguments that you pass to this procedure (such as options controlling the size, shape, and color of the arrows or general plot options such as those controlling the display of axes) will be passed on to plots:-arrow.

A:= [<1,1>, <2,2>, <3,3>]:

HeadToTail:= proc(L::list(Vector(2)))
local L0:= [<0,0>, L[..-2][]];
     plots:-arrow(L0, L -~ L0, args[2..]);
end proc:
     
HeadToTail(A);

I entered your equation into dsolve in Maple 16 and I got a solution.

eq:= (-2*r*beta(t)+J)*diff(beta(t),t$2)+sin(beta(t))*(r*diff(beta(t),t)^2+g)=0:
dsolve(eq);

In this case, it means that you made a syntax error. The y in your difeq should be y(x). That is how you indicate to Maple that y is the dependent variable and x is the independent variable.

Of course you get errors: You're using Matlab code in Maple. The syntax is completely different. Maple syntax is much more compact and intuitive. Here is how to do it in Maple:

a0:= 80;  a1:= -5;  b1:= -5*(3)^0.5;  w:= Pi/12;  k:= 0.2;
U0:= [65,70,95]:
T:= 0..100:
c0:= u0-a0-(k^2*a1-k*w*b1)/(k^2+w^2);
c1:= (k^2*a1-k*w*b1)/(k^2+w^2);
d1:= (k*w*a1+k^2*b1)/(k^2+w^2);
u:= a0+c0*exp(-k*t)+c1*cos(w*t)+d1*sin(w*t);
plot(
     [seq(u, u0= U0)], t= T, legend= [seq('u'(0)= u0, u0= U0)],
     color= [red, black, green], linestyle= [solid, dash, solid]
);

Using the S and t from your original Question, the idea of Tom Leslie can be implemented like this:

S3:= zip((x,y)-> [x[1],x[2]*y], S, CurveFitting:-ArrayInterpolation(rtable(t), S[..,1]));

By the way, "serie" is not an English word. The word is "series" whether it's singular or plural.

Your understanding of the theory is a bit off. The function has a minimum if the matrix of second derivatives (called the Hessian) is positive definite. This is the same as the eigenvalues of the Hessian being all positive. The determinant of a matrix is the product of its eigenvalues, but it alone will not reveal the signs of the eigenvalues.

The worksheet below answers your problem #1.

Download 2nd_derivative_test.mw

@tomleslie A second alternative:

M:= Matrix(5,`+`);

seq(`*`(L4[1..k]), k= 1..nops([L4]));

There is a scaling problem because the values in X are so close together. You can rescale simply by subtracting 616.3 from each element of X:

g:= expand(subs(x= x+616.3, Statistics:-Fit(a+b*x+c*x^2, X -~ 616.3, Y, x));

Now, you just get a warning message saying that there are zero degrees of freedom, which just means that there are the same number of data points as parameters.

Similar results can be achieved with

CurveFitting:-PolynomialInterpolation(X,Y,x);

If you have a some guesses as to the general form of the curve and you are looking for a curve that approximates the data but does not necessarily pass through every point, use Statistics:-NonlinearFit or Statistics:-LinearFit. It's hard to say more without seeing your data.

This is a very difficult problem, and in Maple several intricate steps are required to solve it. I am amazed that it was assigned as a homework problem. Here's an overview of the steps:

1. Get a parameterized numeric dsolve solution with the initial velocity and and air density as parameters.
2. For any given density and initial velocity, extract the numeric x- and y-coordinate functions from the dsolve solution.
3. Use fsolve on the x-coordinate function to determine the time required for the ball to get to the home-run distance.
4. Put that time into the y-coordinate function to determine whether the ball clears the home-run fence.
5. Repeat steps 2-4 with different initial velocities to determine the minimal initial velocity needed to clear the home-run fence. (Unfortunately, fsolve is too fussy to perform this step. I had to resort to a crude bisection root-finding method.)
6. Repeat steps 2-5 with a different air density.

By Boyle's Law, pressure is proportional to density, so 10% lower air pressure corresponds to 10% lower air density.

Download homerun.mw

Try using a restart command. I am able to execute your Explore command without any problem.

Use an epsilon (I used 1 below) to change all your strict inequalities to nonstrict. Then pass them to Optimization:-LPSolve with any objective function (I used 0 below). 

e:= 1:
Optimization:-LPSolve(
     0,
     {x1 >= 0+e, x1+x2 >= 300+e, x2 <= 1000-e,
     x1+x2 <= 700-e, x2 >= 0+e, x1 <= 1000-e}
);

I think that my approach to making a color bar legend is sufficienty different from those found in the links that Alejandro provided that it is worth posting; however, it suffers the same drawback as all the others---that Maple's array plotting function allocates equal space to the color bar and to the main plot. The major difference is how I use plottools:-transform to extract the z-range from the plot.

First, make your plot and assign it to a variable. It can be any 3D plot produced with shading= zhue; it does not need to be produced with plot3d.

plot3d(x+y, x= 0..1, y= 0..1, shading= zhue);
P:= %:

(Plot omitted for brevity.) The following appliable module extracts the minimum and maximum z-coordinates from a 3D plot.

minMax:= module()
local min, Max;
export
     filter:= proc(x,y,z)
          if z::numeric then
               if z < min then min:= z end if;
               if z > Max then Max:= z end if
          end if;
          [x,y,z]
     end proc,
     ModuleApply:= proc(P::specfunc(anything, PLOT3D))
          min:= infinity;  Max:= -infinity;
          plottools:-transform(filter)(P);
          `..`(min,Max)
     end proc
;
end module;

Now use the plot's data to make the color bar:

plots:-tubeplot(
     [0,0,z], z= minMax(P),
     shading= zhue, scaling= constrained, radius= .2, axes= frame,
     tubepoints= 3, style= patchnogrid, orientation= [90,90],
     axis[1,2]= [tickmarks= 0], lightmodel= none
);
colorbar:= %:

Now use an array plot to put the two next to each other:

plots:-display(< P | colorbar >);

(Unfortunately, MaplePrimes cannot handle array plots.)