A MathContainer component is a very poor choice for storing numeric data. That is borne out by the absurdity of having to paste in a whole Matrix (or set its `expression` to the whole Matrix), and the inability to efficiently extract entries.

A DataTable component is much more suitable to storing a Matrix or Vector. A DataTable is tied directly to an actual Matrix/Vector so programmatic extraction and update is as usual, and efficient. The data is stored in the document and available after restart or close/re-open. 

@Earl 

It is a common misunderstanding about the solve command that it somehow requires you to solve for all variables, or is otherwise weirdly picky about which.

A related misunderstanding is that when solve returns NULL it means that there is no solution at all for the supplied variables. But it can mean that there is no solution for the solving-variables that allows the remaining variables to be unrestricted.

The essence is in whether solve can return solutions in which all the variables are either free or defined in terms of those that are free.

In your example you cannot solve only for xp, since x and tp are otherwise restricted. And you cannot solve for just xp, x, and tp because then t and v are still restricted. Even if you evaluate those particular expressions PrimeTime and PrimeLength beforehand at the special values of x and tp then solve would still need to get at least one of t or v as a solving variable, because t and v are restricted by each other.

So if you want to utilize solve for your example then you have to include at least one of t or v in the set of solving-variables (or pass the parametric option so that restrictions can be handled and expressed via piecewise, but that has limited support for inequalites and non-polynomial expressions).

Another command for this kind of thing (often overlooked) is eliminate. For your example it can return a formula for xp (and other solving-variable subsets) as well as the set of restrictions on the remaining variables.

When the second component of the list returned by eliminate is the empty set then there are no restrictions on the remaining variables, which means that the particular call to eliminate would also have succeeded with solve.

See attached: SpecialRelativity_1.mw

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.