The procedure below handles, with the greatest possible generality, all cases of multivariate functional iteration. It uses a combination of unapply and eval, and can be used as a replacement for eval or `@@`. It is often far more efficient than `@@` because it uses a repeated squaring algorithm. As far as I can determine, this is the only usage of a repeated squaring algorithm for functional iteration.

Download MultivarIterate.mw

The function IsSubspace that you want isn't predefined in Maple, but it can be built as a one-liner from LinearAlgebra:-IntersectionBasis like this:

IsSubspace:= (U::set(Vector), V::set(Vector))->
     andmap(u-> LinearAlgebra:-IntersectionBasis([u, V]) <> {}, U)
:

And it's used like this:

IsSubspace({<0,1,0>, <0,0,1>}, {<1,0,0>, <0,1,0>, <0,0,1>});

     true

An approach that would be more computationally efficient would be based on examining the row-echelon form of the matrix formed by the columns of V on the left augmented by the columns of U on the right. I don't feel like coding that right now, but I suspect that it could be done also as a one-liner using LinearAlgebra:-LinearSolve. I'll do it tomorrow, if someone else doesn't do it first.

The output of both procedures is now 0, 0, 1, 1. That's because assign is now built-in, and thus it can alter an environment variable. In earlier Maple, assign was written in Maple, so it any change that it made to an environment variable would revert as soon as assign exited.

If you want to see any output in a simple form, use lprint.

int(1/(x-a)/(x-b), x= -infinity..infinity);
lprint(%);

piecewise(And(a = RootOf(Im(_Z)), b = RootOf(Im(_Z))), undefined, Im(a) = 0, undefined, Im(b) = 0, undefined, I*Pi*(signum(0, Im(a), 1)-signum(0, Im(b), 1))/(a-b))

I suspect that the symbol that you were having trouble undetstanding is the script I that Maple uses to prettyprint Im.

Perhaps you're looking for a more-automatic way, such as a method that tells you that (-1+d1) and (-2+d1) are the best subexpressions to substitute for.

Download Most-common_subexpressions.mw

The model is linear in the parameters a and b, which is all that's needed for it to be a linear fit problem. The implicit nature of the model can be handled by subtracting one side from the other and using 0 as the dependent variable values.

Download Implicit_linear_fit.mw

It looks like you have a very good fit. The p-values are very impressive, especially considering that there's only four data and two degrees of freedom.

I guess that it bothers you to need to select the variable with respect to which to eliminate. Your first inclination is f__F; Kitonum's is L. It turns out that there are an amazing five choices of variable that lead to the same simplest possible final form. The following line of code finds all possible injective substitutions (there are seven!) and tries them all:

map2(simplify@eval, nb, op~(select(s-> nops(s)=1, map2(solve, hh, `[]`~([indets(hh)[]])))));

[(gamma*upsilon-delta__1122^k*tau)*rho, (gamma*upsilon-delta__1122^k*tau)*rho, (gamma*upsilon-delta__1122^(L*lambda*upsilon*tau*v*(sigma-1)/(L*lambda*tau*upsilon*v+f__F*rho*sigma*tau^2-f__F*rho*sigma*upsilon^2))*tau)*rho, (gamma*upsilon-delta__1122^k*tau)*rho, -(k-sigma+1)*lambda*L*(gamma*upsilon-delta__1122^k*tau)*upsilon*tau*v/(f__F*sigma*(tau^2-upsilon^2)*k), (gamma*upsilon-delta__1122^k*tau)*rho, (gamma*upsilon-delta__1122^k*tau)*rho]

When you look at it with 2-D ouput, it's obvious that there are five in the simplest form. If you just want the simplest form selected automatically, do

sort(%, key= length)[1];

(gamma*upsilon-delta__1122^k*tau)*rho

First, some case corrections: Ln should be ln, pi should be Pi, and S should be s. Second, it's poor style (though not an error) to use .5 as an exponent; I changed these to sqrt. Using exponent (1/2) would also be okay.

The plot can be done by substituting z^(1/3) for R/R[0] and then using plots:-implicitplot.

eq:=
     ln(2*s*t+2*s*sqrt(t/Pi)*z^(1/3)+z^(2/3)) =
     2*s/sqrt(2*Pi*s-s^2)*(arctan((s+z^(1/3)*sqrt(Pi/t))/sqrt(2*Pi*s-s^2)) - Pi/2);

plots:-implicitplot(
     map2(eval, eq, s=~ [.01, .005, .003]), t= .01..99, z= 0..2, gridrefine= 3,
     color= [red, green, blue], labels= [t, typeset([R/R__0]^3)],
     legend= (s=~ [.01, .005, .003])
);

R:= solve(Fx, x);
a:= `+`(R)/2;
b:= (R[1]-a)^2;

I find it easiest to put the information into a Matrix and then put the Matrix into a spreadsheet. Here's an example:

restart:
R:= RandomTools:-Generate(float(range= -2..2), makeproc):
f:= randpoly([p,x,y]);

M:= Matrix([
     seq(
          [S[1], S[2][1], eval([x,y], S[2][2])[]],
          S= [seq(
               [
                     p,
                     Optimization:-Maximize(
                          f, x= -2..2, y= -2..2,
                          initialpoint= ([x,y]=~ ['R()' $ 2])
                     )
               ],
               p= 0..1, 0.1
          )]
     )
]);

Spread:-CreateSpreadsheet(MySpreadsheet);
Spread:-SetMatrix(MySpreadsheet, M, 3, 3); #(3,3) is starting (row,column) in spread sheet.

Code edited to randomize the initial point.

Good Question. Do the legended and unlegended plots in separate plot commands and paste the results together with plots:-display, like this:

plots:-display(
     plot(
          [cos(x)^2, 1-(1/2)*x],
          x = -Pi .. Pi,
          legend = [typeset("Curve: ", cos(x)^2), typeset("Curve: ", 1-(1/2)*x)]
     ),
     plot(x^2, x= -Pi..Pi)
);

You're misinterpretting the placement of the horizontal axis. Maple doesn't always place it at y = 0. In this case, it placed it at the minimum y-value, 1.2. Look at the numbers on the vertical axis to confirm this. If you want to see the axes with their normal placement, use

plot({3.8+2.6*sin(50*Pi*t), 5}, t= 0..0.05, axes= normal, view= [0..0.05, -1..7]);

You can also "probe" values on the graph with the mouse. Right-click on the graph, select Manipulator, then Point Probe. Right-click again, select Probe Info, then Nearest Point on Line. Now you can trace your mouse along the curve and see the values.

There's an undocumented command inner for dot products that won't use the conjugate:

inner(vector([x,y,z]), vector([a,b,c]));

Use plottools:-sphere to plot an actual small sphere at each point.

You must be using Maple's garbage 2-D input mode. You original code probably contained the statement

ans(ind):= [op([1], f1max), roll];

If you had been using Maple's 1-D input, this statement only has one possible interpretation (in context): You are assigning an Array element. With garbage 2-D input, Maple tells you that the statement can be interpretted as either a remember table assignment or a function definition and asks you to choose which. (Note that the correct interpretation isn't even one of the choices; however, remember table assignment is effectively the same as Array assignment for the purpose of this question.) Two weeks ago, you selected "remember table assignment"; today you selected "function definition".

If you use 1-D input (aka Maple Input), you'll avoid this problem, and you won't have to answer a stupid question every time you run your code. 2-D input is garbage: No reasonable language asks the end user to provide an interpretation for the code every time a program is run.