The sort command can be used to rearrange the additive terms in some kinds of polynomial, using a flavour of monomial ordering. It works by replacing the particular expression's form that the kernel stores in its table of "uniquified" expressions (aka "simpl" table).

I can cook one up for your example, by eye. For such a monic example it'd be easy to write a procedure that does a subsindets on suitable `+` subterms -- where the action involves a scan and a sort call.

Download sort_ex.mw

But the facility is restricted. You can easily construct a more general example for which none of the available sortings would be able to achive the goal.

Download positive_function_ac.mw

Append the string with the full location of the .mla file to libname, in Maple. For example,

   libname := libname, "C:/Users/Lisa6/Documents/myfolder/filename.mla";

You only need to do that once per session, so you could put it at the beginning of your worksheet, or right after a restart .

Note that a .mla file can contain several things. It's possible that your file blah.mla also happens to contain a module package blah, so that you can issue the with(blah); command. But the name of the things stored in your blah.mla file may be named differently.

A unit is not part of the embedded component per se.

But you can force a particular unit for a particular dimension, as a preference set with the Units:-UseUnit command. And that will get carried over to what is put inside a MathContainer. For example,

Download UseUnit_EC.mw

You can also re-express something in terms of units of compatible dimension. And that can always be done directly, without Units:-UseUnit . Again, the unit is simply a part of the expression, and not specific to the embedded component. For example,

Download Unit_EC.mw

In either scenario above you could also produce results in terms of kN/m if you prefer. The component step would be done similarly.

Download Unit_kN.mw

There are several ways to get such an effect.

You should be able to adjust the following easily (to alter the colors or symbolsize, include the axes, remove the blue circle, slow it down with more frames, etc). If you want help just state precisely what effects you want. Or see the Help pages for Topics like animate or plot,options .

Download circle_trace.mw

I find that one of the easiest ways to start doing an animation is to contruct a procedure that produces just a single frame. Here, the procedure G can be called to show a single frame. For example,

G(Pi/4)

That makes calling plots:-animate much simpler. And it allows you to test easily the generation of any particular frame, without having to build the whole animation.

Your a and b are Matrices whose entries are Vectors.

You could consider something like these (alas, there is no andzip).

   andmap(evalb,Equal~(a,b));

   Equal~(a,b);

If you need extra efficiency -- with false return upon the first mismatch -- you could write your own.

Your first use of PDEtools[declare] makes psi(t) appear as just psi in output. But it doesn't affect input, and in your usage you'd still need to type psi(t) if you want to refer to it.

The Physics:-diff command will allow you to differentiate with respect to psi(t).

The name theta__l gets prettyprinted with an underscore. You could use another name if you'd prefer to avoid that.

Download DiffExpr_ac.mw

You could use the DocumentTools:-Tabulate command to embed a GUI Table of values. The values and column headings are constructed in a Matrix.

In the attached, I show two ways to handle the column headings (y3 and y4, with the formula for the latter shown explicitly). You can make both column headers the same, of course, using which form you prefer.

The attached also shows a variant of the above is to use a DataFrame structure instead of a Matrix, but I find that a little awkward.

The Tabulate command has several options, which allow you to customice the cell coloring, border display, column weighting, Table width, etc.

InverseNum_ac.mw

You can do this with either a procedure or an expression. In other words, you really don't have to use unapply. I'll show both, below.

I'm guessing that you want to use several values between 0 and 1, in which case you can supply a 3rd argument to to seq to specify the increment.

For example,

Download seq_range.mw

One of the basic things to learn in Maple is the distinction between expressions and procedures. (An operator is a special kind of procedure that displays with the arrow notation.)

I realize that you may be quite used to instructors and textbooks using the term "function". But using that term in the context of Maple code can be confusing, since people might not always understand whether you mean expression or procedure.

Also, while your example can indeed work using operators, there's really no need for them here. The combine simplification needs expressions, and explicitly putting combine into the procedure body is inefficient.

There's little to no merit in using an operator f if you are just going to invoke it as f(x) every time you want to do a computation with expressions. It'd be simpler and cleaner to just use an expression directly.

In 2D Input mode the syntax,
   f(x,y) := ...something...
is an alternate syntax for assigning the operator,
   f := (x,y) -> ...something...
Unfortunately the first of those does something quite different in 1D plaintext Maple notation (or with different 2D Input preferences) and so it is ambiguous in the Maple language. I suggest that you think hard about whether you want to use ambiguous Maple syntax just to get a familiar looking math look & feel. I use the second form, below.

Download expr_oper_combine.mw

Your code has several mistakes.

Why do you have Ps[i][] in the odeplot call, when Ps is not a list of lists? The use of Ps and Pc is all muddled up. Explain, properly, what your intention is for those.

Why do you have theta(eta) in the odeplot call? Did you intend f(eta) or something else?

Where did you copy the code from? Was it from an earlier Question on Mapleprimes -- perhaps from someone taking the same course, before you?

I have a suggestion: instead of simply trying to reuse (someone else's?) object-oriented, (and undocumented?) code you should either learn how each part of it works, or try to program the task yourself in simple steps. That way you might actually learn how to use Maple for solving such bvp problems, and it'd help you in your future tasks as well.

This is a common issue, especially for coders new to Maple.

You made the central and germane statement, "It appears that fieldplot3d is attempting to evaluate the statements within the procedure, instead of simply calling the procedure with numerical values." It is excellent that you got to that idea. You are correct. Maple's usual model of evaluation during procedure calls is to evaluate the arguments up front, before the procedure body does the computation.

Sometimes (like in your problematic example) this situation is referred to as premature evaluation. The procedure PUV was not prepared to deal with some nonnumeric arguments. And, for symbolic arguments (x,y,z), the function call PUV(x,y,z) was evaluated prematurely.

The most common scenario for encountering this problem is with an if..then statement. In fact, if you click on the magenta error message in your Document then (provided your Maple GUI is set up to call your web browser) it will take you to this Help page which addresses this issue. In your original worksheet, if you call PUV(x,y,z) by itself then you'll see the same error message.

For your example the cleanest way to resolve this problem is to alter the body of your procedure so that it can handle nonnumeric arguments. Member Kitonum's Answer shows that you can simply utilize 2-argument arctan and remove the conditional queries. And member Preben Alsholm's Answer explains that you can utilize a piecewise structure and so defer the conditional branching until a numeric value is supplied.

But those kind of approaches are not always easy to accomplish gracefully. So, for fun in these lockdown times, we can take a brief look at some blunter methods.

The Help page to which I linked shows two ways to deal with the issue. There is an extra wrinkle, however, in the fact that fieldplot3d needs three items (expressions in a list, or expressions in a Vector, or procedures in a list). But otherwise the approaches illustrated in that Help page are still possible:
1) Delay the up-front evaluation of the function call using right (forward) single-quotes, aka uneval-quotes. Here is that approach, for your example. fieldplot3d_and_if_statements_ac1.mw
2) Use the operator form calling-sequence of fieldplot3d, instead of the expression form. That is shown in member vv's Answer.

I'll also give a variant on 1), since uneval-quotes are ephemeral:
3) You could adjust the procedure PUV so that it returns unevaluated if some of the arguments are not numeric. fieldplot3d_and_if_statements_ac2.mw

Approaches 1) and 3) both index into the unevaluated function call since in those cases three expressions need to be passed for fieldplot3d and, when numeric x-y values get substituted, each result from PUV will be a Vector. Approach 2) also involves indexed calls to PUV, for the same reason. So all of these approaches actually call PUV three times for every numeric x-y pair. In order not to make triple the computational effort the procedure PUV can be given option remember, so that the second and third call (with the same, repeated numeric x-y pair) can be done with a quick lookup of a stored result.

You can increase Digits and call the LPSolve command from the Optimization package.

See the Help pages with those terms as Topic.

You might be making the mistake of using lowercase pi instead of Pi.

If I accidentally use the "Evaluate at a Point" context-menu item and supply lowercase 2*pi as the value for t then I'll get the same result as you. But lowercase pi is just a name, with no special meaning to Maple.

But if I use the capitalized Pi in the "Evaluate at a Point" context-menu item, and supply 2*Pi as the value for t then the output is the expected result.

Download Pi_versus_pi.mw

S := -A/Pi*Sum((-1)^k*sin(2*Pi*k*f*(t-Pi/8))/k,k=1..N):

bg := plots:-display(
  plot(fmod(t,Pi/4)*4/Pi-1/2,t=0..Pi,color=blue,thickness=1),
  plots:-pointplot([seq([[i*Pi/4,0.5],[(i-1)*Pi/4,-0.5]][],i=1..4)],
                   symbol=solidcircle,symbolsize=8,color=white),
  plots:-pointplot([seq([[i*Pi/4,0.5],[(i-1)*Pi/4,-0.5]][],i=1..4)],
                   symbol=circle,symbolsize=12,color=blue)):

F := n -> plots:-display(bg,
    plot(eval(S,[A=1,f=4/Pi,:-N=round(n)]),t=0..Pi,
         thickness=1,color=red,numpoints=max(2,10*round(n))),
    plots:-textplot([0.35,-1.0,sprintf("N = %-2ld",round(n))],
                    font=["Monospaced","bold"])):

L := [0$8, 1$8, 2$8, 3$8, $4..49, 50$12]: # delay by repeating
plots:-animate(F,[N],N=L,frames=nops(L),paraminfo=false,
               xtickmarks=[],ytickmarks=[],axis[2]=[color=white],
               axis[1]=[color="#9090FF",thickness=0],size=[600,300],
               labels=[``,``],view=[Pi/16..Pi-Pi/16,-1.25..1.25]);