The indexing/selection notation is reliable and documented, and not new.

It's also very commonly used.

By the way, you typo'd in the alternative syntax that you wrote that you'd usually go for.

Download ind_ex.mw

ps. Apart from its terseness (on top of its commonness and efficiency) this indexing/selection notation has another advantage over using op. With square-bracket indexing the notation also works for Vectors and Matrices. Sometimes this adds the convenience that the same code can handle either Vector/Matrix as well as list, or do so with only minor adjustment.

I'm a bit pressed to think of situations in which using op like that would be preferable, except for the rare (for me) situation where I was trying to prep for a subsop call, and was double-checking/forming my op call's details.

A Vector is a mutable data-structure, and its entries can be changed in-place.

That's not true of lists. (in-place replacement into a list "fakes" the in-place aspect, and actually creates a new list in memory.)

You could assign Vectors to names A and B  and they might happen to have the same entries at some moment. But they are still two different containers, whose entries might later change.

You could instead compare the two Vector instances with, say, EqualEntries.

This is not a bad question; variants have been asked many times before. Here's a good one.

And here's some fun, with is,

Download Vec_andmap.mw

Is there a reason for you to not use the Calendar package?

For example (and you can tweak this in various documented ways  including which hour on the reference date, how many finer-level fields you pick out, etc.),

Download Calendar_ex.mw 

Without using parse and a format, you could also pick off values using static exports of the constructed Date object, eg, using a procedure such as,

     jd -> [':-Year',':-Month',':-DayOfMonth'](
                  Calendar:-AdjustDateField(Date(-4712,1,1,12),"date",jd))[]:

Perhaps the simplest way would be something like,

    seq(11 .. 234, 11)

I describe it as simple because it uses only your original values of 11 and 234, and doesn't require that you also know how to come up with the extra value of 21 which is iquo(234,11) .

But read on for others, some close to your attempt, some also simple, etc.

You could read the help-page for the iquo and irem commands, and utilize those. (There are many ways to proceed, and for your very small example the efficiency differences will be small.)

(This site isn't showing the full results from this do-loop; but they show in Maple itself.)

Here are five ways, starting with an edited variant of what you were trying with a loop.

Download if_question_i.mw

The third way does,
   seq(i*11, i=1 .. 21)
but it also shows you how that value of 21 can be obtained, using iquo(234,11) .

The fourth way just calls seq, using 11 for the increment.

You could compare the efficiency of doing a single iquo call, versus using irem (or your other divisibility test) for multiple values. The 5th way illustrates (analogously to the 4th way) that if you get your loop increment right then you don't need a divisibility test for each value of the loop index.

Here is one way,

Download PDEtools_solve_march_28_2026_ac.mw

Most all type's can also be used like a property. (See second bullet point on the ?property Help page)

But many properties do not match any type, and those cannot be used as a type.

NonZero is a property, but not a type.

Non(0) is a type specification, and can be used like a property check.

ps. The Help page for ?property states that Not can be used as a synonym for Non, which means that they can be used in a similar manner (ie. for their primary purpose of property-checks, and, as it happens, for type-checks). It doesn't state that they are existentially identical.

pps. You mentioned that you can "combine" properties. With a similar kind of effect, for types,
   And(integer,Non(0))
   Or(posint,negint)

It is unclear (to me) what your full requirements are.

The explanation seems incomplete. You could provide a comprehensive set of different input and their desired outputs (just as data, not with calls to the procedure). The guess work is awkward.

Here's one guess:

Download 2026-02-28_Q_Test_proc_Line_point_inputs_ac.mw

Even though your equations might not have an explicit solution for x in terms of r (except say x=4 when r=0 or something trivial), you could still get a black-box thing like an unevaluated procedure call -- that evaluates to a float upon substitution.

For example, (and this can be tweaked in a few ways, but first let's see if it'd serve...)

Download bbox_ex1.mw

If you think that kind of thing won't suffice then you should explain clearly and in full what it is that you'd hope to do with an explicit formula.

ps. I changed the floats in your originals to exact rationals, so that there wouldn't be up-front loss of precision. It's nicer to be able to see these procedures scale up with Digits.

In Maple 2025.2 (but not Maple 2026.0, for some reason) the following attains from solve with its allsolutions option passed,

Download s_ex.mw

2026-03-26_Q_Module_Generic_Variables_ac.mw

nb. I don't know what kinds of indexable structure you might want to use to pass the "variables". So, in the procedure's parameter specification, you could utilize varp::list:=TM:-Parmvars or varp::list(name):=TM:-Parmvars (or several of variants) rather than just varp:=TM:-Parmvars.  I don't know how restrictive you might want to make it.

The discont=true option can work if the fallback value for the piecewise is undefined instead of [] the empty list.

Using Maple 2026.0,

plot_piecewise_march_25_2026_ac.mw

Maple 2025.2 and Maple 2026.0 return true (and 0) for these, without any conversion.

You're not doing something wrong; it's a bug, that has since been improved.

Download test1_ac.mw

In Maple 2024.2 you could also convert to trigh (ie. change the lhs rather than the rhs).

I've submitted a report on this in the past. But it couldn't hurt (and might help) if you'd like to submit your own bug report against it.

The font used (and possibly also that Component's spacing) is not the same on all of the Windows/Linux/Mac OS's. On my Maple 2024.2 for Linux I can fit 16 numerals into a TextArea with "Visible Character Width" set to 10.

On Linux (at least) the font used for TextArea components is not a fixed-width font, so it matters which characters are used. It's unclear what is meant by "Visible Character Width" in such a context. See lowercase "i" vs uppercase "W".

[edit]
Best solution: fixed-width font that has same size and appearance on all three OS (and if that can't be done in Java, then... oof).
Worst solution: same fonts as now, but a component that adjusts visible width according to its running content.

The SupportTools version shipped in Maple 2026.0 has a flaw that interferes with its Update command.

But it's possible to update the original SupportTools in Maple 2026, from the the MapleCloud via GUI login, or with the Maple command

    PackageTools:-Install(4797495082876928);

And that contains not just the first set of its Library fixes for 2026 but also a fix for SupportTools itself.

ps. I copied this from a response in the Beta users forum.

In 2D Input mode you can get that combination is a few different ways.

You can get it by using command-completion. For example, in 2D Input mode (the default for new users), simply type the keystrokes   Delta   and then hit the Escape key. And then once you have the Greek letter shown you can type Q, etc.

You can also get it in 2D Input mode by selecting the typeset Greek Delta from the palettes. It's available from the Greek palette. And if you'd like you can produce it alone as an output and then select&drag that to your Favorites palette.

Either of those two approaches could be used to produce the following,

Download Q.mw

In 1D Input mode (not the default for new users) you could enter that combination as the plaintext code,

    `ΔQ`

and you'd see the typeset Greek letter in the output.

ps. I'm not sure what you intend on the left-hand side of your assignment statement. Be careful about using Q followed by an apostrophe unless you right-click on it in the input and turn it into an Atomic Identifier (a mere name). Otherwise you might get it interpreted as a call to diff, ie. diff(Q(x),x), from the prime notation in calculus; and you wouldn't want to assign to that.