As a workaround you could utilize the is command.

Download unitsineq_is.mw

Here is another way to accomplish the same results, using eval instead of assign.

Download Q20220416_ac.mw

It is quite often a better way, IMO, especially if you need to continue to use the unassigned names x[i] (or those Cost/TotatCost formulas, etc) symbolically in further computations.

In the above I used a Matrix instead of the deprecated lowercase array structure. If you really insist on using that deprecated array data structure then you can still accomplish the goals using eval instead of assign.  Q20220416_acm.mw

Download simp_ex.mw

I will submit a bug report (SCR), that the simplify command itself does not attain this simplification.

Hardware floating-point precision real and complex linear-algebra is mainly accomplished using the Intel MKL, with parallelized BLAS and LAPACK.

That affects many packages, including LinearAlgebra as well as some commands in other packages (ArrayTools, Statistics, Optimization, etc).

You can disable this parallelization with the follow setting of this environment variable in the shell (Operating System shell) in which Maple is launched:

    OMP_NUM_THREADS=1

Similarly, you can restrict that paralellization, eg. setting 8 as its value.

The first example below is to address the OP's requirement, "I want them to appear as vectors when I type them". That is, the over-arrow appears on the input as well as output.

The point of the 2nd example is that the symbol is bold in both input and output.

The 2nd and 3rd examples look more bold in the actual Maple GUI than they do with the worksheet inlined in this forum.

Download accents_bold_atomic_var.mw

Your computation can be done more quickly using the Quantile command. The purely numeric approach (first below) doesn't quite match to all digits.

Download test_fsolve_integ_ac22.mw

As for computing it by numerically integrating the PDF, here is one way to adjust your original, using the inert Int(...) instead of the active int(...) as you had it, along with operator form calling sequences.

It's important to not use the active int and let it attempt int(f(x),x=0..y) for symbolic name y.

Download test_fsolve_integ_ac.mw

That is reasonably quick, but even this can be done quicker, by unapplying the explicit symbolic PDF result, so that it doesn't have to call PDF for each point, while integrating. (Interestingly adding the numeric option to an unevaluated PDF call doesn't seem to help here.) Ie,

Download test_fsolve_integ_ac2.mw

The numeric integration of the PDF can also be done using the CDF command.

Download test_fsolve_integ_ac3.mw

This regression in behavior is a bug, I think. (I will submit a report.) It is a problematic change in one aspect of the behavior of the Histogram command.

Here is a very simple solution to handle your example, requiring only a wrapping call to plots:-display.

with(Statistics):
X := RandomVariable(Normal(1, 2)):
w := Sample(X, 1000):
plots:-display(Histogram(w), legend = "data set 1");

Below I edit the Histogram procedure's parameter/option specification, to get the original legend functionality back, to cover this example more directly.

If the following works for you then you might consider temporarily adding the redefinition part to an initialization file. That would allow you to utilize Histogram directly and straightforwardly, as in Maple 2021, etc.

Download Histogram_legend_M2022.0_ac.mw

One kludgie approach is to use either the `caption` or `title` option instead of `legend`, but that doesn't automatically get the colored rectangle. It also doesn't merge properly if you display a few of them together. So IMO this is an inferior alternative for the behaviour you want. But the behavior you want is fully reasonable.

Are you allowed a wider range than your specified lw..up = 0.01..10 ?

After correcting the syntax problems with multiplication that Preben mentioned, I go the following.

Notice that these solutions all seem to be permutations involving the same numeric values -- with some entries lying outside your specified range 0.01..10 .

Download eqs_sys_iso.mw

You can wrap the result from seq in square brackets, in order to make a list from the sequence of numbers.

  L := [seq(a(n), n = 1 .. 100)];
  plots:-listplot(L);
 

Do you mean like this?

seq([seq([a[i,j],b[(j-1)*3+i]],i=1..3)], j=1..3);

   [[a[1, 1], b[1]], [a[2, 1], b[2]], [a[3, 1], b[3]]],

   [[a[1, 2], b[4]], [a[2, 2], b[5]], [a[3, 2], b[6]]],

   [[a[1, 3], b[7]], [a[2, 3], b[8]], [a[3, 3], b[9]]]

Or, if with slightly different bracketing,

seq(seq([a[i,j],b[(j-1)*3+i]],i=1..3), j=1..3);

   [a[1, 1], b[1]], [a[2, 1], b[2]], [a[3, 1], b[3]],
   [a[1, 2], b[4]], [a[2, 2], b[5]], [a[3, 2], b[6]],
   [a[1, 3], b[7]], [a[2, 3], b[8]], [a[3, 3], b[9]]

This runs in Maple 18.02 (since your Questions are usually restricted to that old version).

Download collect_exp2_18.mw

In the above code the term
   exp(-I*(-Omega*t+k*x+z*k[1]))
is deliberately kept as you gave it, ie. not turned into
   exp(I*(Omega*t-k*x-z*k[1]))
or
   1/exp(I*(-Omega*t+k*x+z*k[1]))

And similarly for the other exp call.

Also, a term like
   exp(-I*(-Omega*t+k*x+z*k[1]))^2
is deliberately kept as is, and not turned into
   exp(-2*I*(-Omega*t+k*x+z*k[1]))

You have not informed us as to which variables are to be considered as purely real. So I am guessing that all the indeterminates can be taken as purely real. You originally omitted similar information in another of your recent Questions. This is not helpful.

You asked why your loop approach cannot be replaced with seq.

So I will show you how your seq attempt can be easily adjusted to work, using the prefix form of `+=`.

Using your N, V, and sumidx,

roll:=rand(1..9):
N := sort([seq(seq(10*(2+jdx)+roll(),jdx=1..5),idx=1..10)]):
V := 10*seq(roll()+10*trunc(N[idx]/10),idx=1..nops(N)):
sumidx := [seq(floor(N[idx]/10)-2,idx=1..nops(N))];

You can now proceed with,

S := 0 *~convert(convert(trunc~(N/10),set),list):
seq(`+=`(S[ sumidx[idx] ],V[idx]), idx=1..nops(N)):
S;

     [3420, 4570, 5480, 6620, 7320]

which agrees with your loop approach,

S := 0 *~convert(convert(trunc~(N/10),set),list):
for idx to nops(sumidx) do
    S[ sumidx[idx] ] += V[idx]:
end do:
S;

     [3420, 4570, 5480, 6620, 7320]

A slightly wider pair of ranges for the parameters (along with a restricted vertical view) can help avoid the impression that the two surfaces are equal along a certain direction.

You can also play around with the stylistic effects.

plot3d([exp(t^2+10*u-1), -121+22*t+10*u, [[11, -12, 1]]],
       t=8..12, u=-15..-6, view=-50..50,
       color=[grey,green,red], style=[patch,surface,point],
       symbol=solidcircle, symbolsize=10,
       lightmodel=Light2, transparency=[0.4,0.0,0.0]);

It can get tricky finding a decent view, since a wider range (ie. larger t) alongside the restricted view can cause the GUI's plot render to fail to show one of the surfaces.

Here is one way to avoid calls to TF from happening (prematurely), ie. unless its arguments are not all of type realcons.

Download Min_ex.mw

Here are some ideas, which you should be able to adjust.

I find that for animations of compound plots it's useful to create a procedure (below, F) which can be used to quickly generate and test each frame -- calling it with only a value for the animating parameter. Eg,  F(0.5) etc.

Then you can more quickly adjust that procedure, as needed.

And then the call to plots:-animate is very simple as a last step.

Download plotting_anim_textplot.mw