Yes, this is handled in Maple 2017 via new Typesetting:-Settings(typesetdot) functionality.

See the second bullet point of the first section of the help page with topic updates,Maple2017,compatibility .

Download dotfun.mw

It looks like you may have inadvertently entered one of those r-subscript-i instances as r__i instead of r[i] , in that call to `seq`.

Make sure that those subscripts are with square bracket indexing and not with double underscores. Otherwise they won't be mutable with respect to index `i` as it takes on takes from 1 to 8.

Also make sure that all the others are like r[1] , r[2] , etc.

In other words, you need to be consistent.

The alternative is to use double underscore subscripting for all 8, and then build the pair inside `seq` dynamically with concatenation. That would be ugly code.

For the example with HankelH1(0,...), without the change of variables. And a few observations about handling the imaginary part.

Download IntcosBesselJ.mw

[edited] Somehow I missed the following simpler variant, in which after converting to the integrand `Bessel` the extra assumptions on the Bessel calls are not needed. (I wonder what I was doing that made me think it was needed above... likely I just got confused.)

Download IntcosBesselJ_2.mw

The name Psi is the name of an assigned special function in Maple. Use another name. Eg,

restart;
with(PDEtools):

U := diff_table(PSI(`ψ_2`, `ψ_1`)):

pde := `ψ_2`*(diff(PSI(`ψ_2`,`ψ_1`),`ψ_1`))+`ψ_1`*U[`ψ_1`]+2*U[] = 0:

pdsolve(pde);

                                   _F1(ψ_2)
          PSI(ψ_2, ψ_1) = --------------------
                                                    2
                                 (ψ_1 + ψ_2)

The most important thing that I suspect you might not have realized is that there is a huge difference between the typeset 2D Math ft as a unit (which gets pretty-printed in upright roman font) versus ft as a name (which gets pretty-printed in italics).

Before Maple 2017 units were typeset within double-brace fencing. In Maple 2017 the braces have gone, which is nice for some people but confusing for others.

There are three common ways to enter an actual unit:
1) Using the Units palette (in the left panel of the GUI). This always typesets it in upright roman, even for input.
2) Typing the keystrokes Unit, and then either typing in round-brackets to make that a function call, or using command-completion (Esc key, say) to turn such 2D Input into the brace-less upright roman font form.
3) Typing keyboard accelerations like Alt-shift-u (for Linux, but varies with platforms) to get into unit entry mode.

Attached below are a Worksheet with 1D Maple Notation and a Document with 2D Input (I used command-completion to enter all the units for the Document).

I've utilized the Units:-Simple package so that arithmetic operations done at the top-level combine units.

I've shown the combine(...,units) command which is the best way to combine units into the "base unit" for the final dimensions of a result.

I've used the Units:-UseUnit command to force the "base unit" for several different combinations of dimension (you may wish to augment this). I find this much superior to the right-click Units Formatting since the latter has to be done every time one wants a result in a preferred unit rather than the default unit for a given dimension.

units1.mw

units2.mw

I'll also mention that if you loaded the Units:-Natural package (instead of Units:-Standard or Units:-Simple) then you would be able to type in names and symbols of units without any extra work (palettes, Unit() command, keyboard acceleration, etc). That's how many Mathcad users are used to doing things. The problem with that scheme in Maple is that things get just too awkward with such a huge number of single-letter names being effectively removed from one's global namespace. Almost nobody uses Units:-Natural . (I consider it unworkable, and wish it would go away...) If you do  not load this subpackage then you cannot simply type a name like `feet` and have Maple interpret it as a unit, but instead you need to use 1), 2), or 3) above (or cut & paste from some actual unit).

Once again, it appears that you are looking for pretty-printed output, since for 2D Input there's little difficulty.

I'll leave aside the approach of building it with the mouse using palettes (or command completion for the Greek), and then conversion to Atomic Identifier via the right-click menu. You've been shown that in another recent thread.

We can construct TypeMK (the stuff that atomic identifiers are made of) for this.

Download typemk.mw

Presumably your question is about the pretty-printing of 2D Math output.

This was done in Maple 16.02, but may work in your Maple 13.
 

Download verbar.mw

@mapleatha 

In 2D Input mode you can enter A=B=C , or A+lamda I = A+ 4I = B , say. Then right-click on it and choose the context-menu action 2-D Math -> Convert To -> Atomic Variable in the menus that pop up. That turns it into a name which pretty-prints as output like the original input. In Maple 13 it is called an Atomic Identifier, I believe.

You can also create 2D Math expressions which do not execute, and you can also intersperse those within paragraphs of text, say. That is possible in Maple 13 too, I believe.

In a Document in Maple 2017 you could also enter such a thing in 2D Input, and then hover the mouse cursor near its end to reveal a round toggle button that can be used to disable execution of the line.

In this was you can create quite a variety of expository mathematical formulas which don't necessarily have to parse and evaluate to valid Maple language constructs.

In the example Document below I used the right-click conversion to the inputs assigned to foo and bar, and toggled the Q+R+S to non-executable. This was in Maple 2017.3.

Download 2datomic.mw

Here are some examples executed in Maple 13 (including convert-to-atomic-identifier on the rhs of the assignments to foo and bar).

The left-alignment below is an artefact of inlining into Mapleprimes; the items were centered in Maple 13's GUI.

Download 2dm13.mw

Using Maple 2017.2,

restart;

assume(nu > 2, beta > 0, lambda > 0, delta > 0, y >= 0):

S:=dsolve(beta+y+(D(h))(y) = nu*((lambda+beta+y)^2-delta*h(y))^(1/2)):

subsindets(simplify(S),RootOf,u->map(simplify,u));

[edited: I see that the OP has since indicated he is using 2016.2]

For Maple 2016.2 you could try instead,

subsindets(simplify(simplify(S),size), RootOf,
           u->map(uu->simplify(simplify(uu),size),u));

The syntax to load the package is,

   with(simplex)

and not,

   with simplex

as your Comment indicates.

Note the there should be no space between the "h" of "with" and the opening round bracket.

The round brackets are required, since here they denote a function call to the `with` command, and they are not merely separators.

Since the problem appears to be with just the pretty-printing of those names then you should be able to get by, say by avoiding that. (You don't need them beautiful for some purpose, do you?)

If you don't want to have to temporarily switch typesetting level then you could lprint or sprintf or print (or suppress output).

This has been reported as a bug on this site before, btw.

Consider your first example. It is not working for the reason you think, I suspect. What seems more likely is that plot3d is receiving as its first argument the list of three scalar expressions in x and y that is returned by the evaluation of se(x,y) where x and y have no assigned values. In this way that call plot3d(se(x,y),x=0..2,y=-2..3) matches a valid and documented calling sequence of the plot3d command.

For your second example plot3d(td(x,t),x=0..2,t=0..3) your should first execute the call td(x,t) and see what it returns. That is what you are passing to the plot3d command here.

The plot3d command, like most Maple commands, follow the so-calling standard evaluation rules of evaluating arguments before they are passed to the procedure.

A procedure (of say two arguments) which returns a list of three elements is not one of the valid calling sequences of the plot3d command. An unevaluated function call, like say the single right-quoted call 'td(x,t)' , which might evaluate to a 3 element list when x and t take on values, is also not a valid calling sequence of the plot3d command.

For Question 1:

Depending on your specific architecture hyperthreading may or may not interfere with  the efficiency of Grid computations.

You could see what happens if you disable hyperthreading in your machine's BIOS.

One scenario in which the derivatives appearing in the prettyprinting of a "Vector" do not get formatted in dot-notation is when it is handling a VectorCalculus:-Vector. I don't see mention of that package in your Question.

If you are using the global constructor :-Vector when you use the shortcut <...> (by virtue of not having loaded VectorCalculus, say) then it seems to work OK in Maple 2016.2. See attachment.

If you do indeed want VectorCalculus loaded and/or want its results to be prettyprinted with dot-notation, then you could get dot-notation for its "Vector" results by wrapping them in the command :-Vector(...) . That would give you the BasisFormat(false) appearance. I don't see any easy way to get the dot-notation displayed in the BasisFormat(true) style in Maple 2016.2.

usedot20162.mw

Your posted example suffers from computational issues (e.g roundoff error), rather than a display-driver problem.

Short workaround:

restart;
CodeTools:-Usage( plot(x->eval(evalf[20]((1-x)^(10^9))), 0..10^(-15)) ):
memory used=6.48MiB, alloc change=33.00MiB, cpu time=36.00ms, real time=39.00ms, gc time=0ns

Usually a more natural way to deal with such an issue is simply to raise Digits at the level at which you are calling plot. But, as seen at the end of the following code, there are some unexpected issues with that approach for your example as given.

(Link to the attached worksheet is at the end.)

plotprob.mw