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

The plotting command plots:-surfdata can handle a 2-dimensional Array or Matrix of data (z-values). It has the advantage over matrixplot in the sense that surfdata accepts a 2nd and a 3rd parameter to specify the ranges over which to interpret the independent axes.

If I import your attached .xlsx file then I get a 9-by-4 Matrix of values. I could plot that and specify the ranges for the x- and y-axes, but I don't see how the given data can be expected to give a plot like the one in your Question's image.

You could add additonal options, (such as scaling=constrained , etc), to adjust the look&feel of the plot. See the plot3d,options Help page. Of course the data could also be flipped or transposed.

Download surfexample.mw

There are several obstacles in the way of using save and read to store and recover a random variable. There are the attributes. There are the modules. In general modules cannot be properly saved to .m format (it takes storing to .mla format to store module locals), but you might be able to kludge around it here. And there is an unknown risk that Statistics might register some information about the previously generated RVs in some additional location which we don't know about.

I think that your ongoing efforts to rip apart Statistic's RVs -- and put them back together again -- is somewhat dubious. It might be workable, but perhaps only partially. It clearly wasn't designed for that. (The package predates objects, and uses its own special, undocumented techniques to get object-oriented effects.)

So I would suggest that instead you store whatever is needed to create the RVs afresh -- using only stock, documented Statistics commands like RandomVariable, Distribution, etc).

Having said that, you might find the following of some interest (Maple 2020.0). I hope that it's clear that the following is in the dubious realm, and not what I meant by using stock, documented techniques.

Download RV_save_read.mw

There are several ways to go about this.

For example, you could obtain the result directly using the value command (or the active int command).

Or, if it's homework and you've been told to do it in a particular fashion, you could do it step by step. There too you have several choices about how to go about it. I'll give just one way, utilizing integration-by-parts, as illustration. (In this case I don't know what knowledge you have. If you do not see how integration-by-parts is working in each of the three calls below then please say so.)

Or, are you expected to express the formula for integration-by-parts, and then substitute for the various parts, exactly as if you were doing it by hand on paper?

I don't see limits of integration in your Question. Did you intend on supplying them?

Download example_byparts.mw

See the smartview option on the plot,options Help page

Download plot_view_problem_smartview.mw