N := 20; 

... other code, and then,

plot3d( {seq(a[i], i=1...N)}, ... );

It's natural that a list would always be exported with one particular orientation, and it happens to be as a row.

But conversion of a list to a column Vector can be done much more easily than by using the convert command.

Try this,

Export( <X1>, "data1.xlsx", 1, "A1" );

You can insert an image from an external image file into a Rectangle within a Drawing.

You can insert the rectangle using the corresponding icon in the Drawing tool menubar (you may wish to first make the color white, to suppress the rectangle's borders). You can then select and fill that rectangle using the corresponding selection and fill (paintcan) icons, to make it contain the image from the external file.

A semicircle image can be produced by exporting a plot, or by using the new ImageTools-Draw commands.

You may need to be careful about resizing the rectangle, and matching its dimensions aspect-ratio to that of the file, in order to get a clean non-jagged curve.

It would be useful if the GUI were to allow a copy of a plot to be pasted into a selected Rectangle within a Drawing canvas.

Another approach is to use the Drawing tools menubar to draw on top of a displayed plot.

Here's an example I made using Maple 2019.1 and both of those two ways I mentioned above to produce an image file.

Download drawing_semicircle.mw

For the particular kind of polynomial expression you have, it is possible to use the sort command to alter the way in which the structure is currently stored in memory by the kernel. And doing so also forces the way it is displayed by printing. And so in this manner you can obtain what you requested.

It's possible that you will find this approach too heavy-handed, and will prefer to use the InertForm and the %-prefix operators for your display goal. But, contrary to what Carl wrote (as I read it and interpreted the claim), for your given example it is possible to control the orders of the multiplicands in the `*` terms.

Note also that since the forced sorting affects how the operands are stored then it also affects how they get accessed with the op command.

It is possible to get such an effect by applying the sort command to the whole polynomial at hand, or to get a mixed result by applying it to just a few of the individual product terms (even before calling add).

This topic is also related to the fact that Maple only stores a single instance of such product terms in memory, and for efficiency uniquifies equivalent input to the single stored representation.

Note that in the absence of such a forced sort call the default display may differ for prettyprint=3 and prettyprint=1 or 0. (There is some extra subtlety, and there are now different kinds of underlying DAG structure that can come into play, as can be seen using the advanced dismantle command.)

I've tried to illustrate some of the effects below:

Download exchangeproblem_ac.mw

Since the OP seems interested in Maple 2018,

Download RDsolve_example_2018.mw

How about using an object?

That has a constructor which you need define only once (ie. centrally). And it is supported by the type system.

That is the return value of the call to Tabulate.

You can simply use a statement-terminating colon to suppress it.

Why not write a shell script (text file, with suitable hash bang first line), and ensure that sets its own environment adequately? You could pass arguments along to that, via ssystem.

It's not clear why all you tried before lead nowhere. Why are .cshrc and tcsh and python not referenced with absolute paths?

Surely you should instead refer to shell executable by explicit full location (whether it be to a new shell script file, or to tcsh, or what else that is not a 'sh' builtin).

And how you form strings of commands (possible containing escaped double quotes, or other sttings) to pass along  can matter. It's not clear precisely what you have tried.

You asked at least one other question in the last two weeks about patmatch, where the convincing answer was that indets is the better tool for the job at hand.

In at least one exchange you seemed to resist that idea.

And now you seem to have completely forgotten about indets altogether. (That seems weird, to me.)

Please consider the following: indets is one of the most basic tools in Maple, being both fast and flexible. As a result it is very commonly used within stock Library commands.

In contrast patmatch can be slow and quite difficult to use flexibly and robustly. It is very rarely used in stock Library commands.

Your current example is handled by a simple call to indets. I encourage you to figure out the exact call yourself, as doing so would help your understanding and could greatly aid your future Maple development work.

note: the great advantage of indets is that it works with Maple types. The type system is very highly developed in Maple and works closely with the underlying structure of expressions. It's understandable that a Mathematica user would think first to code with patterns, since Mma's pattern-matching is highly developed and works more closely in conjunction with its expression structures. Since Maple and Mathematica have different expression strucures (and supporting tools) then the best mechanisms for matching substructures are also different.

Some years ago I answered a similar question, using a hand-rolled procedure I named &// which would apply its second argument to its first.

Eg,

   foo &// simplify;

would execute simplify(foo). This syntax works even if foo is some involved function call -- where foo gets applied to the result of that.

I only have a cell phone right now, and cannot easily find that old post. I'm sure someone else could write it quickly.

I expect it went something like this (possibly with a few defensive checks)

`&//` := proc(a,b)
             b(a):
end proc;

So then it could get used as follows,

cos(x)^2+sin(x)^2 &// simplify;

Sometimes (but not always), conversion to exp form can help. But the effort to simplify may also vary by example.

And the Roots command can sometime be useful for results within a finite range.

It just so happens that convert to exp form helps produce a simpler set of parametrized formula for the very first example. But I have seen examples where conversion to exp form prevent solve from finding the proper full general solution.

Below I include both the original and the revised example. The techniques that can be practically applied are slightly different.

Download trig_sols2.mw

(I wrote this before Mariusz's followup for the second example, which also does conversion to exp form.)

Here's one way. (No doubt it could be slicker.)

Download blockify.mw

First I downloaded that problematic Dtm.mw file, and then I ran the following command using the location to which I saved it.

The generated string of 1D code is not perfect (it has some escaped double-quotes). But it visually shows S*(k+1) as the left hand side of an invalid assignment. And if I manually remove the escaped double-quotes (escaped special characters) and try to run it then I receive an error message about that as an invalid assignment.

Download Dtm_text.mw

[edited] It's understandable, perhaps, that this utility might baulk at complete conversion of input that has a syntax error. I think that it's obvious that code containing a syntax error is in general not translatable. Even though the incorrect syntax for the given example does have a rather obvious and natural 1D analogue.

You might concoct your own procedure to instantiate a given RV at specific values for its parameters.

For example (and you could make this more bullet proof with some additional, defensive checks),

Download RV_instantiate.mw

This also works for deeper nesting.

A1 := {1,2,{5,6},3,{13,{{21,27},16}},{8,9},{{11,12},4}};

        A1 := {1, 2, 3, {4, {11, 12}}, {5, 6},
               {8, 9},{13, {16, {21, 27}}}}

{subsindets(A1,set,op)};

        {1, 2, 3, 4, 5, 6, 8, 9, 11, 12, 13, 16, 21, 27}