Another approach is to store the loop index value k and the value of a in a table, and then turn that into a Matrix as a later step.

That allows you to easily handle the situation where some entries are omitted (because, say, they fail some conditional test). You can still have easy access to the accepted indices and values, and plot just those.

Here's an example. There are other ways to accomplish the same thing, some of which are terser, but I've tried to keep it understandable.

Download table_aug_Matrix.mw

I'm not sure how you're expecting the omega(t) values to be used. But this may be a start, or give you some ideas.

The key part here is that I'm using my earlier idea (see Reply above) of using a custom procedure F which can generate each frame.

Once you have such a procedure it is easier to test. You can call it with different arguments and see how it looks. When satisfied you can easily animate it.

[edit] I have adjusted the shape that I plotted with my method.

Download how_rot_ac.mw

By calling parse you turn the strings back into Maple expressions, so naturally when you print them as normal output then you get the same effect as for the original, ie. sequences are pretty-printed with spaces after the commas, whether they are in a list or just as a sequence.

If you want to line-print strings, without the quotation marks appearing, then you could use printf (on the strings, with %s format) instead of print or lprint. Note that conversion to strings might be unnecessary -- your particular goal is still unclear.

If you want to export the entries to an external file then you could use the ExportMatrix command, eg.,
    ExportMatrix("myfile.csv", Matrix([ans1]));
That produces a file named myfile.csv with three lines, each with the entries separated by commas and without spaces. That command has some additional flexibility along those aspects.

What are you actually trying to accomplish with sequences of numbers displayed without spaces after the commas? Are you trying to export it to an external file, for some other software? Or are you going to copy&paste from what is displayed on your Maple GUI?

It is a very common phenomenon on this forum for people to have some task they want to solve, then ask about only part of their approach to solving it, without describing the actual underlying goal or full process that they want. This usually leads to guesswork and unnecessary and inefficient back-and-forth.

In the Maple programming language (1D plaintext, also known as Maple Notation) the word for infinity is:

   infinity

That entry box in the popup is a Maplets TextField, and it expects plaintext Maple Notation.

This seems to be a consequence of the result from DiagonalMatrix having shape=diagonal and storage=diagonal.

A workaround is to force off the compact shape/storage (see two ways, below).

I will submit a bug report.

Download Starnge_ac.mw

Is you lprint the SearchSet you can see that its float values are not what appears in the 2D Input.

I don't know how you managed to get that effect (cut&paste, something with numeric formatting?).

You could re-enter it manually.

But you may still be faced by discrepencies if you expect floats to be matched in the case that they have differing numbers of trailing zeroes.

It might be better if you described precisely what kind of matching you are after, ie. float comparisons to a fixed precision, etc. It may be that verify it a more suitable tool for the comparison, but that depends on what comparison you are after.

Also, you asked about why some sorting occurs. That's how Maple acts with sets of floats. If you don't want them sorted then you could use lists of Vectors instead.

Download Binary_search_ac.mw

An explicitl description of what you're actually trying to accomplish would be a good start to getting best advice.

It would be more helpful and direct if you were to supply the complete example when first submitting the Question.

Hopefully this uses the dsolve solution to produce your line animation in a satisfactory manner.

Download anim_ac.mw

You have b assigned as a Matrix. That's your basic mistake, since you were only indexing into it as b[i], as if it had just one dimension.

Try making it b as a Vector instead, ie,

   b := Vector(3, [-1, 7, -7]);

Below, I have removed also the loading of the VectorCalculus package since that rebinds the Vector command which is hardly useful here. I changed the call of Norm to be explicitly a call to LinearAlgebra:-Norm.

I suggest that you check that it works as you intended.

Download code_zeineb_ac.mw

It is not necessary to write M:-Pn instead of just Pn (for each n), in the situation you describe.

In my experience is far more common to write the references as just Pn in equivalent situations.

You wrote that using the form M:-Pn somestimes "...saved me a lot of trouble". What trouble was that?

If you store them properly (in a .mla Maple Library Archive file) then you wouldn't need to read any of them in each session you want to access them, and they could all get seen as easily as each other.

To access any of them you'd simply need libname to be augmented with the location of the new personal .mla Library file.

- You could augment libname in a worksheet's Startup code, which would affect just that worksheet.
- Or you could augment libname in a personal initialization file.
- Alternatively you could put the .mla Library file under a new folder with a name like whatever the following returns, and have Maple automatically augment libname upon relaunch:
    cat(kernelopts(':-homedir'),"/maple/toolbox/mypackage/lib")

Personally, I think that reading in the plaintext source files each time you want to run a session or worksheet is an unnecessary, overly complicated burden.

But if for some strange reason I was unable to use an .mla file, then I'd probably just create a single .mpl text file that contained the means to input all the individual procedures. That could contain various (say, five) read calls for each of the individual source files, or it could contain the definition of a package module that accessed the individual sources with, say, the $include directive. In this scenario I could subsequently issue one read call of that master (build) file, and all would be avaliable.

[edit] There is an example of writing a module using the $include directive (and the preprocessor) for its member procedures in Section 11.4 of the Programming Guide.

You may well be satisfied with the right-click context-menu approach.

By the way, there is a Help page for that (it takes a little while to fully load and focus on the approriate section in my webbrowser).

Using the result in the left-hand side of an assignment requires mouse actions to copy&paste, so using the mouse to convert to Atomic Variable may be fine.

If you're interested, your expression can also be converted programmatically:

Download atomicvar_constr.mw

ps. In versions before Maple 2017 an Atomic Variable was called an Atomic Identifier.

Try

   ':-b' = b

using single right-ticks (a.k.a. uneval quotes).

The LHS of that equation is an unevaluated reference to the global name b (and not the procedure test1's parameter by a similar name). The RHS evaluates to the value you want to pass along.

test1:=proc(a::posint, {b::posint:=1})::posint:
	return a + b:
end proc:

test2:=proc(a::posint, {b::posint:=1} )::posint:
	return a*test1(a, ':-b' = b);
end proc:

test2(2, b=3);
             10

[edit] I much prefer this approach over using _options['b'], which Joe has suggested.

I would not use remove(has, ..., unit) since that would act quite differently on expressions other than a product. (Your expression assigned to a is of type `*`, but it's unclear that is all you want to be able to handle robustly.)

I would suggest these preliminary steps be part of the process:
1) combine addends into common units
2) optionally convert to a preferred unit (or accept the base unit for the current system, default=SI)
3) use convert(...,unit_free) to strip off the remaning units, as suitable

For example, quoting unprotected global versions of option names for robustness,

Download remove_units.mw

Maple was originally designed for efficient symbolic computation, as opposed to pretty mathematical typesetting.

A key aspect of that original design was the storing in a session (by the Maple engine, a.k.a. "kernel") of only one representation of any sum or product of terms (commuting under usual addition and multiplication). Any other input of an equivalent form of an expression -- with terms commuted -- gets uniquified to the stored form.

Hence, if the form
   -b + a
is first formed in a session then construction/entry of the alternate form,
  a - b
gets automatically recognized as the earlier, stored form.

However, for this kind of expression the terms can be reordered by the sort command. For example,

Download simpl_examp.mw

As far as mathematical typesetting goes, one could also display the expression (in marked up "2D" math), without the above issues interfering. Here I use so-called inert operators, so avoid those uniquification issues,

Download inert_add_ex.mw

If you have other, particular usage scenarios then you should describe them precisely, as a best bet on getting adequate assistance.

You asked about plotting the elements of a sequence, so I'll address that aspect.

You can use the plot command to show a discrete collection of x-y points.

The data can be formed in a list of lists, or a Matrix. (I'll do it as a list of lists, below.)

You can adjust other qualities, such as the symbol, the style, the color, etc. See the Help page plot,coptions for more details.

Download point_plot_ex.mw