You can get around this problem in Maple 2022 with the following,

  VectorCalculus:-PlotVector(w, unconstrainedview = false)

In Maple 2022, the PlotVector command is passing the option unconstrained=true to the plots:-arrow command.

That is the problem, a consequence of which is that for your example it generates a plot structure with Float(undefined), which appears blank. Up until Maple 2020.2 it did not do this, and the example worked ok.

As dharr mentioned, this is a bug. In a simpler example of the problem, the following renders as an "empty" plot in Maple 2022 (or Maple 2021.2),

   plots:-arrow([-2,1],[1, 2],unconstrainedview = true)

That seems to go wrong (Maple 2022) with suspect methodology and a (float) division by zero at line 15 of plottools:-arrow2d,
   showstat(plottools::arrow2d,1..15);
 

Is it less noticeable if the right panel (context-menu panel) is collapsed/hidden?

The following attachment contains as much as I can recover (which is significantly more than what the Maple GUI can recover: see notes below).

Eksamenssæt_ac.mw

There were four corrupted and unrecoverable inputs.
1) Opgave 1, section (ii), after "Herefter konjugeres matrix".
2) Opgave 2, section (i), right at its start.
3) Opgave 2, section (ii), just after "Basis for søjlerummet:"
4) Opgave 2), section (ii), just after "Basis for rækkerummet:"

I shall add this example to an earlier bug report I submitted. The underlying problem is the same as the (new) kind that I've only seen since Maple 2022, of an invalid and unclosed Equation XML element.

Do you remember what was at those four missing inputs? Were they all 2D Matrix inputs from the Matrix palette, perhaps? Or anything else that they might have had in common? Such detail might help the GUI developers fix this particular cause.

A DataTable embedded component allows you to enter numeric data in a tabular input format.

In my Maple 2022.2 for Linux I can press the tab key to advance the cursor through the cells of that component.

This also obviates the need to parse the cells, as entering a changed entry in any of the cells is accompanied by an automatic update to the named Matrix (or rtable) associated with the component (one of its properties).

Also, the data and the named Matrix are stored along with the worksheet and directly available upon close/re-open.

There is not a convenient mechanism for controlling the numeric formatting of the display of the entries (if floating-point, say).

The first operand of a procedure is its parameter sequence.

So, if that procedure has been assigned to the name q,

q := (u,v) -> u^2 + v^2:

nops([op(1,eval(q))]);

                2

note: you wrote "arguments", but here we're counting the parameters of the procedure (in its definition), not the arguments (which is what get passed when it's called).

As a followup query you asked about finding extrema of rhs(eq1).

The following shows a local minimum, and a saddle point.

Download extrema_example.mw 

Be careful about misinterpreting spikes in your 3D plot as being finite extrema. Those could indicate a curve along which the expression is discontinuous (eg. not finite), in which case the visually apparent spikes may be merely artefacts due to the granularity of the plot's sampling process.

Consider these curves along which the denominator of rhs(eq1) is zero, ie. rhs(eq1) is +-infinity.

plots:-implicitplot(denom(rhs(eq1)));

The following attachment has one Input Equation (XML) removed, that I believe occurred above and near the text line:
   PC1

PCA_ac.mw

It is concerning that this is the third instance of the very same particular kind of corruption that I've seen reported in the last eight days; see here and here. I am going to amend a bug report to note that:
1) The problem appears to new (to Maple 2022.2?) and to not be rare (which is alarming).
2) The GUI fails to recover significant portions of these corrupted Documents, when it attempts its own recovery.

I'd like to see the underlying problem fixed if possible, but I'd also really like to see the GUI do a much better job of recovery. I've submitted more than one previous bug report on that latter aspect.

I am supposing that you are a Danish student, because of your use of the Gym package.

If you can remember what was in the missing 2D Input line that might be helpful. Did it have Danish characters/accents? Any little knowledge of it might be better than nothing.

You could pass the signchange=false option to implicitplot, so that discontinuties in f2 (eg. switching from +infinity to -infinity) are not shown.

If there's a jump discontinuity across which the sign is changed then that's not the same as an actual root.

Download oneman_impl.mw

[edit] Here is one solution to the OP's followup query of what (apparently) they actually wanted. It's not clear to me what is wanted when the function call does not have exactly three arguments.

Download printf_sub_ex2.mw

[end edit. Below is my original response to the original Question.]

The pretty-printing of BesselJ can be controlled by calling appropriately the command,
    Typesetting:-EnableTypesetRule

The related Typesetting commands don't seem designed to allow for customization of user-defined functions. But there's nothing to stop you from using the remember table for its QueryTypesetRule as a semaphore within a user-defined custom print-extension procedure such as `print/f`.

For example,

Download printf_ext_ex.mw

The following link is as much as I can recover from your upload called "Cengel2.mw". It has recovered significantly more than the Maple 2022.2 GUI is able to recover.

Cengel2_ac.mw

(I suspect that is contains as much as could possibly be recovered by any means. The problem appears to be the same as in another example I saw very recently on Dec 12. A single Equation XML element in an Input was invalid. Its removal -- leaving all parent elements intact -- appears to achieve maximal recovery. I have seen many corrupt worksheets before, but up until then never that particular issue. I wonder whether the cause was new, or something common to M2022.2.)

Your wrote "how to combine an expression", but what you show as your goal is a new operator (not an expression) whose body happens to contain the combined form.

x := t -> sin(a)*cos(t) + cos(a)*sin(t):

x := unapply(combine(x(t)),t);

    x := t -> sin(a+t)

You haven't shown where your original operator came from. But perhaps it would be more convenient to begin with just expressions, then do all your manipulations, and then use (using, say unapply) form operators only as needed.

Forming operators manually and then only ever using then with function calls like x(t) -- to get an intermediate expression -- seems an awkward workflow.

As N gets larger is more efficient to do,

   Matrix(N,N,fill=undefined)

than,

   Matrix(N,N,(i,j)->undefined)

The technique you apply may need to depend on what you know of the form of the input. That depends on how robust you want to make it if the form is slightly different, ie. how much defensive programming you wish to have.

Here are some alternatives, using subsindets or subsop.

Add_range_ac.mw

The matter of whether the command used involves an external call is not central. Nor is whether the command is a "library function" or a kernel builtin, or what have you.

It's also unlikely the RealDomain:-simplify is going to be a place to find such functionality in the near future, IMO.

The first place that I'd hope to find the functionality, as you've expressed it algebraically, would be under the is and coulditbe commands. For example, [have I expressed this correctly?]

restart;
F1 := a + b + c + d > 0
      and
      a*b + a*c + a*d + b*c + b*d + c*d > a^2 + b^2 + c^2 + d^2:
F2 := d*c*b*a > 0
      and
      a*b*c + a*b*d + a*c*d + b*c*d > 0:

not is( F1 and not F2 ) assuming real;
                              true

Unfortunately several equivalent forms returned FAIL (after taking a while).

After that I might hope to find it using is under assumptions. Then perhaps simplify (but not using &implies).

In Maple 2018.2 (and 2022.2, say)

eq := binomial(2*n, n)/2 = binomial(2*n-1, n-1):

is( expand(eq) ) assuming n::posint;

             true

Also for n::integer, n<>0 it seems.