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}

restart;

X := Statistics:-RandomVariable(Normal(0, 1)):
pp:=[attributes(X)][3]:
pp:-ParentName;
                       NormalDistribution
pp:-Parameters;
                             [0, 1]

Y := Statistics:-RandomVariable(Normal(5, 17)):
pp:=[attributes(Y)][3]:
pp:-ParentName;
                       NormalDistribution
pp:-Parameters;
                            [5, 17]

Z := Statistics:-RandomVariable(Exponential(3)):
pp:=[attributes(Z)][3]:
pp:-ParentName;
                    ExponentialDistribution
pp:-Parameters;
                              [3]

You can easily construct your own float[8] Array to denote the color, using either HUE or RGB specification.

Download color_pointplot.mw

On MS-Windows I add the following undocumented option (following a blank space) to the launch command in the Properties of the desktop icon,

  -standalone

The main effect, apparently, is that the icon subsequently launches wholly separate java virtual machines.

If one of these GUI instances crashes (while printing a huge result, rotating a huge plot, waiting on a crashed Maple kernel, etc) then the other GUI instance remains responsive and its worksheets can still be saved properly and promptly, etc.

Since I quite often run multiple GUI sessions, often with examples that can crash the GUI, this has been very useful in saving my other work in progress.

My machine has adequate RAM, and I don't care that separate GUI JVMs can take up 300MB footprint each while running. It is much more valuable to me that I don't lose work in progress.

(Sorry, I did not notice this Question before now.)

One way to disable the discontinuity check done by evalf(Int(...)) is to use operator form for the integrand. And fsolve prefers everything in operator form when it detects such (even if not really necessary for a numeric scalar like 0.5 on the rhs).

restart;
fe := Int(x -> sqrt(1+(-5.557990765*sin(5.557990765*x)-7.3*cos(5.557990765*x)
               -5.6*sinh(5.557990765*x)+7.3*cosh(5.557990765*x))^2), 0 .. al) = 0.5:

fsolve(unapply((lhs-rhs)(fe), al), 0..1);

                          0.1550088024

That works even when the original int call had already been formed for the given example: We can recast the int call with integrand in expression form to an Int call with integrand in operator form.

restart;
fe := int(sqrt(1+(-5.557990765*sin(5.557990765*x)-7.3*cos(5.557990765*x)
          -5.6*sinh(5.557990765*x)+7.3*cosh(5.557990765*x))^2), x=0 .. al) = 0.5:

F := subsindets(fe, specfunc({int,Int}),
                u->Int(unapply(op(1,u),lhs(op(2,u))),rhs(op(2,u)),op(3..,u))):

fsolve(unapply((lhs-rhs)(F), al), 0..1);

                          0.1550088024

Now some comments about Maple's numeric integration.

It is long-standing and unfortunate behaviour that evalf(Int(...)) (ie, numeric integration) offers no all-round easy option to disable its examination of the integrand for discontinuities.

The important 1D numeric quadrature schemes utilized have error estimates that rely on certain degrees of smoothness, and thus they should often split the domain in the presence of a finite number of discontinuities. But there are lots of examples where the check for discontinuity consumes enormous resources, and where that check is not necessary or wanted (because there are no such points).

The typical unfortunate scenario occurs when a symbolic discontinutiy check on an expression containing float coefficients causes a symbolic expansion which runs amok when the floats get converted to exact rationals with large numerator or denominator.

Sometimes the check can be avoided by specifiying the method=_d01ajc for evalf(Int(...)) example. But that method requires Digits<=15, and when the calling environment has default Digits=10 then fsolve may try and resolve the question of convergence (or a root candidate) at yet higher working precision.

While it would indeed be useful if fsolve were to accept an accuracy tolerance option, the runaway crash in this particular example is due (IMO) to a bug in evalf(Int(...)) and not in fsolve.

In my opinion it is a very longstanding and serious bug that evalf(Int(...)) offers no option to forcibly disable its discontinuity test. I have answered dozens of Mapleprimes questions over the years where evalf(Int(...)) showed serious performance problems for users, where it was not originally obvious that the discontinuity check was the culprit.

I have seen several examples that don't involve fsolve at all, where the evalf(Int(...)) misbehaviour causes unnecessary very slow performance or even a crash. Some of these are plotting examples. Some are simply single instances of a numeric integration. The central problem is not in fsolve.

Consider this example, which runs amok (don't try it if you don't want a crash):

restart;
Q := Int(sqrt(1+(-5.557990765*sin(5.557990765*x)-7.3*cos(5.557990765*x)
         -5.6*sinh(5.557990765*x)+7.3*cosh(5.557990765*x))^2), x=0 .. al):
evalf[25](eval(Q,al=0.3));

The way that I disable the discontinuity check at the start of this Answer is to use operator form for the integrand. That can become very tricky when the problem involves nested integrals or integrands that depend on (scoped) parameters, etc. It can become so tricky that it really cannot be considered a practical alternative to a (currently missing) dedicated option to prevent the discontinuity check.

Here is the first plot obtained in the worksheet below, but without the blue plane. It has a smooth lower edge and no missing portion (for larger y values).

An upper bound y=20 was supplied. For the first approach below you could increase that (and the `view`, accordingly). An upper bound for the z was also supplied, in the `view` option, which you could also adjust to taste.

Download plot3d_inequality.mw

Here are a few ways, each involving just a few calls to LinearAlgebra:-GenerateMatrix.

I didn't keep exactly the same names as you have for Vector X, etc.

I include the situation where the final LHS is left in the form Matrix.diff(X) , as opposed to being fully explicit.

(But I would not be surprised if there were utilities to help in DEtools or PDEtools.)

[edit] I have included a way to print the Matrix equations (using either X.DX, or DX explicitly on the LHS) with inert multiplication. In case you were after such a visual display. For the case of the explicit LHS I've separated the inverse of X using its determinant factor and its adjoint.

Download various2.mw