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.

If all you want are results of numeric double-integration then you may not have to wait for a preliminary, partial and time-consuming symbolic integration.

Check that I re-entered the expressions correctly.

Note that I used inert Int instead of active int. You can tell because the integral symbol is gray not black, on the 2D Input. I entered it using command-completion, not the palettes. (I type Int and then the Escape key to get the template popup.)

It computed very quickly.

Download integral_doubt_ac.mw

Here is some experiment on the smaller 12x12 system, with some simplification.

It might give you some ideas.

Problem_2_ac.mw

An important matter is what you intend on doing with the results. It's not clear why you need the large symbolic answers.

When working with such large expressions it's often a good idea to suppress ouput by terminating commands with a full colon. Checking expressions for a moderate size before displaying in the GUI is often a good idea in such situations.

There are other ways.

ps. What might help, if you have other such expressions or sums or products of such and you want a systematic and programmatic approach, is to provide more complicated examples.

Download manip3.mw

I don't think that you've made it clear how you want to characterize your rearrangement of the expression, which makes it tricky to supply an operation that will work for other (as yet unstated) examples.

Download manipulation.mw

You also need the option,

   adaptive =false

There are several other ways to get the same effect -- using Vectors of the desired length and plotting the data, etc. But you specifically asked about what you needed with the numpoints option for the plot command.

Download LPSolve_ex.mw