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]);

That is a set. 

See the set Help page, and in particular its Description section which should make clear the distinction between a list and a set.

When you're looking at a Help page it's often useful to give a quick glance at the "See Also" links. In this case you could also look at the Help pages for topic type/set and selection .

a := {"bar", "foo"}:

whattype(a);
               set

op(0, a);
               set

type(a, set);
               true

type(a, list);
               false

The entries of a set are stored as an expression sequence, which is also true for a list. The main differences are that the set entries are uniquified (duplicates removed) and reordered automatically, while list enties can have duplicates and are stored in a specified order.

op(a);
            "bar", "foo"

{"bar", "foo"};
           {"bar", "foo"}

{"foo", "bar", "foo"};
           {"bar", "foo"}

["bar", "foo"];
           ["bar", "foo"]

["foo", "bar", "foo"];
         ["foo", "bar", "foo"]

If you are looking to plot the integral against a variable upper limit of integration then these compute very quickly.

Download integral_test_ac.mw

Here are two approaches, the first of which does not need Digits raised high, and is pretty quick and not very complicated. Neither is terribly slow. Do the results concur with your expectation?

Were you hoping to see some explicit rearrangement of terms, so that avoiding numeric difficulties (roundoff and loss of precision, say) were more transparent?

I used Maple 16.02.

Download question_ac.mw

You can save some work by having your rm procedure return both the remainder as well as the quotient.

A surrounding procedure can store the quotients in a table (I used the name T), and then -- when finished -- it can construct a list from the entries stored in T.

It would be inefficient to repeatedly augment a list in a loop. So don't do something like the statement in a loop, for list L,
  L := [op(L), func(a, b)];
That's why I stored the quotients in a table, and only at the end turned that into a list.

(Your could also use irem instead of your rm procedure, but I suppose this is a programming exercise. Also see convert(..., base, ...) .)

restart;

rm := proc(a, b) local n; n := 0;
  while 0 <= b - n*a do b - n*a; n := n + 1; end do;
  return n - 1 , b - (n - 1)*a;
end proc:

cv := proc(a::posint, b::posint)
 local T,i,j,r;
 r := b;
 for i while r <> 0 do
   r,T[i] := rm(a,r);
   #T[i] := irem(r,a,'r')
 end do;
 if i = 1 then
   [0]
 else
   [seq(T[j],j = 1 .. i-1)]
 end if;
end proc:

cv(8, 3657);
                          [1, 1, 1, 7]

convert(3657,base,8);
                          [1, 1, 1, 7]

The  LinearAlgebra,General,LinearSolveItr  help page is missing details for the nonsymmetric solver.

But the method can be supplied using the methodoptions optional parameter, similar to how it is documented for the symmetric solver.

(One could examine the code, to figure out additional suboptions that control the methods.)

Download sparseiterative.mw

If I recall, there's no nice, efficient functionality to apply the preliminary work (preconditioning, etc) to multiple RHSs in separate calls. (I could be misremembering -- I didn't check.)

In Maple 2020 you could use printf with the new P format. Or you could use print.

Of course, you could also use sprintf if you prefer a string as return value.

The rules for when if...then...end clauses get indented are not clear to me.

The example below using print does render with more indentation in the Maple GUI than appears when inlined below. And that survives cut&paste, in my Linux.

[edit] One thing that I prefer about the printf format is that it displays semicolon terminators even when optional (eg. before an end). Of course that is a personal preference. I like that it helps prevent a sloppy typo if an extra line is inserted inbetween (or via an $include).

Another thing -- that might matter in some use cases -- is that printf doesn't contain the extra decoration at the start (ie. the printed name and colon-equals) and it's easier to add it than remove it.

Download format_P.mw