You can use the right-click Unit Formatting facility, or the Units:-UseUnit command.

In the actual Maple GUI the units appear in upright roman without the double-bracing. They appear that way when the worksheet is inlined here on Mapleprimes because that's the "old" way that they used to appear in Maple.

Download unitpref.mw

Starting with a RealRange, you can convert to relations (inequalities) and use the solve command. Union and intersection can be expressed pretty well using inert And and Or.

You can use Open ends, or not, and get strict or nonstrict inequailities accordingly.

Of course, there is nothing stopping you from beginning with inequalities. You don't have to begin from RealRange structures.

Depending on how you express the variables parameter to solve, the result can be in RealRange or relation form.

And so on.

Download solveRealRange.mw

You have used both y(t) and y, and it complains.

Perhaps you intended this:

eq1 := diff(y(t), t) = 1/2*cos(t - 2*y(t));
with(DEtools);
DEplot(eq1, y(t), t = -2 .. 2, y(t) = -2 .. 2);

If you want to substitute for diff(x(t), t, t) you don't have to assign to it.

(I find you intention slightly confusing, since it appears that the substitution is merely the equation from isolating `Eq__λ1`=0 for diff(x(t), t, t), hence the result is zero. If you intended something else then please explain.)

For example,

Download subst_example.mw

Outside the loop (right after calling dsolve) you can make this assignment,

   Y:=eval(y(t),lambdaE):

Then, replace all your calls lambdaE(tCompute[i]) by Y(tCompute[i]) in the later code.

The above works because you used the output=listprocedure option when you called the dsolve command.

If you had omitted the output=listprocedure option then you could get avoid the assignment to Y above, and instead replace all your calls lambdaE(tCompute[i]) by eval(y(t),lambdaE(tCompute[i])) in the subsequent code.

I prefer the way with listprocedure, but that's a stylistic coding preference.

[edit] I could add that it can be needlessly inefficient to call lambdaE(tCompute[i])  (or whatever you replace it with) multiple times for the same numeric value of tCompute[i]. Instead, inside your loop, you could simply call it once and assign the result to a temporary variable.
    temp := lambdaE(tCompute[i]);  # or whatever
And then use temp in the multiple locations your formulas.

Here are two ways.

The first has Nu[a] in italics (because I used single left-quotes to make it a name).

The second has Nu[a] in upright roman.

I specified the axes font, only so that the labels renders more clearly on this site. Adjust as you wish.
 

Download indexedname_label.mw

[edit] A couple of simpler ways (square brackets matching the bold, which you are free remove)
   labels=[eta,Typesetting:-mtext("Nu[a]")(eta)]
and,
   labels=[eta,`#mtext("Nu[a]");`(eta)]

What matters more is how you process and display the results in the second worksheet, rather than how they are returned from the worksheet which computes them.

Let's suppose that your first worksheet does,

   return [matrix(G), matrix(A), matrix(DR), figplot]

do that it returns a list of the items.

Let's suppose that your are making a call like,

   RunWorksheet(...);

in the second worksheet. You could try making that instead be, say,

   results := RunWorksheet(...):
   map(print, results):

That will print each of the results separately, so that the plot renders with its proper size and the matrices don't interfere with each others lines.

Notice that the command above are termined with full colons.

note: Why use lowercase matrix (instead of modern Matrix) which has been deprecated for 20 years?

note: Plots render small when you print them as part of an expression sequence.

note: A fancier way to do all this would be to use Embedded Components in the second worksheet, or Tabulate. But I guess you don't want to change it all.

There is no point-probe functionality provided by the GUI for 3D plots.

If you want the results to be subsequently accessible as integers then you could cast the result from Statistics:-Sample to a hardware datatype integer Array. (I used integer[8] below because my Maple is 64bit, and that provides for a wide range.)

[edit] On my machine this is just over 4 times faster than Carl's code to apply the trunc command after converting to a list.

It also keeps the Sample output as an rtable (in case the code otherwise expected that). Adjustments would be easy if you wanted it to preserve the rtable subtype, eg. keep Vector[row] as Vector[row], etc.

Download int_sample.mw

(It might be nice if the in-place calling sequence for Sample allowed for such an Array as its second argument. That might save on the extra rtable construction/collection.)

It is not very helpful to show us a mere picture of your code instead of uploading and attaching your actual worksheet to your Question.

Yes, the old (and now deprecated) table-based array and matrix are somewhat more awkward to print in your scenario.

Note that assigning to the names u1, etc, only after creation of the structures that reference them doesn't alter the structures themselves. But you can also access entries, or compute with them, and get the evaluation (resolution).

If you want to get a new structure that both contains as well as prints with the entries fully evaluated then you can map the eval command over the earlier made structure.

Here are some examples to consider, using both matrix and Matrix.

Download evalm_misc.mw

ps. Don't set Digits to 5. That is a bad idea, and can incur unnecessary roundoff and numeric error. Instead, either keep Digits=10 the default (or raise it) and utilize evalf[5] as a command to print results more tersely.

cos(Pi/4) is a constant.

You need your plotted expression to contain a dependent variable.

But we cannot know what you want... eg.

  cos(x*Pi/4)

  cos(x+Pi/4)

  cos(x/4)

  cos(x)

and so on.

You should try and find a way to test (at least one d value) of the data points for correctness without the integrand being an operator.

Also, I think that a log plot looks more meaningful for this example.

Download MoJalal_ac.mw

The key thing for the speed is to make use operator form for the integrand (but that disables discontinuity checking, so it should be double-checked at at least one value of d).

(If I didn't mess it up, Carl's code could be treated similarly... Mo_Jalal_ac2.mw But check why the plot is not identical.)

You can use PrintToString, concatenate the missing piece, then write the string to a file, then fclose.

For example, with xml being assigned the representation of the XML in Maple (in function-call form),

str:=cat("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n",
         XMLTools:-PrintToString(xml)):
FileTools:-Text:-WriteString("outfile.mw",str):
fclose("outfile.mw");

ps. You can also use fclose after PrintToFile, to handle (only) the closing aspect.

You can choose a file from a popup with Maplets, using the Maplets[Elements][FileDialogue] element.

Are you computing as evalf(Eigenvectors(?)) on a Matrix with exact integers. If so then much better would be to apply evalf to the Matrix first, and then call Eigenvectors.

Are you trying to estimate the numeric stability of the eigenvector computation using the ConditionNumber command? That relates to solving linear systems, rather than eigen-computations. Instead, see the EigenConditionNumbers command (and its output=conditionvectors option).

If I recall correctly, you can utilize the output of that EigenConditionNumbers command to estimate the error bounds. (See here and here for background. For "machine epsilon" you could use evalhf(DBL_EPSILON) in the hardware float case of Digits<=15 and 1.0*10^(-Digits) in the software float case.)

For your 18x18 example with random integer entries in -5..5 I am not seeing cases where the eigenvector condition numbers are being computed inaccurately at default Digits=15 (and so it seems to me that those can be used to compute error bounds). If that situation is rare then it's not clear to me what is the nature of your problem.

Why not show us your methodology explicitly, where you are seeing a need to raise working precision high in order to get a good estimate of conditioning? I find your Question to be quite unclear as to what commands you have used.