As a tip for future queries,

> MmaTranslator:-FromMma("Hypergeometric0F1Regularized[a, z]");

        hypergeom([], [a], z)
        ---------------------
              GAMMA(a)

> lprint(%);

hypergeom([],[a],z)/GAMMA(a)

How's this?

C_Users_jonas_OneDrive_Skrivebord_Mat_B-A_Hjemmeopgavesæt_Opgavesæt_1115_MAS_-_Kopi_ac.mw

You have used Maple 2021, and 2D Input.

In that case you can use the prefix form of the inert `%.` operator.

Also, to get it to display in infix notation as output, you'd need to utilize the extended typesetting level. (In that case the "dot" appears in gray.)

You can use InertForm:-Display to show the "dot" in black, instead of gray.

And you can use the value command to make the inert call active.

Download inert_matrix_products_M2021.mw

@abert Preben's procedure returns the name of its local z. That is sometimes called an escaped local.

Download escaped_local.mw

As Christian mentioned, the means by which your procedure f evaluates that name z is the same means as for your procedure h, ie. because in both cases the unevaluated name was passed in as the argument.

You mentioned "lexical scope".  Consider the following contrasting example, in which procedure g gets a value for z via lexical scoping. Perhaps you were thinking of something like this, when you wrote of your procedure g, "After all, its definition is within the lexical scope of z."

Download lexical_ex.mw

Note. op(7,eval(g)) is the lexical table of the procedure assigned to g, as mentioned on the Help page for topic proc.

Your original example's procedure g, however, has an empty lexical table, and does not get a value for z via lexical scoping. It gets it because the reference was actually passed.

Fwiw, illustrating six free variables, and all integer solutions:

[k[6] = 22*k[1]-3*k[2]-k[3]-4*k[4]+4*k[5]+3*k[10],
 k[7] = -5*k[1]+k[2]+2*k[3]+10*k[4]-k[5]-k[10],
 k[8] = -14*k[1]+k[2]-k[3]-3*k[4]-3*k[5]+k[10],
 k[9] = -4*k[1]-k[3]-4*k[4]-k[5]-4*k[10]]

That can be had by,

simplify(combine(solve(evalc(convert(eqs,radical)),
                {k[6],k[7],k[8],k[9]}))):

You wrote the k[1]..k[6] are the "unknowns". The following produces a rational solution. This is similar to what Kitonum showed, but without requiring the unguaranteed steps of evalf & identify.

simplify(combine(solve(evalc(convert(eqs,radical)),
                       {k[7],k[8],k[9],k[10]})));

Naturally, you can scale (here, by 3) to get purely integer solutions.

The following would remove spurious imaginary components (eg. small imaginary artefacts due to floating-point roundoff error).

It will also remove remaining complex (ie. non-real) results, so that max can succeed.

temp := [solve(f=0,x)]:

max(select(type,
           simplify(fnormal(evalf(temp)),
                    ':-zero'),
           realcons));

Why haven't you shown us your actual equations, or uploaded and attached a worksheet that produces them? That would make it easier for people to help you.

The simplest way to get the result is to use the solve command.

The way in which the optional second argument is passed to solve controls the form in which the result is returned (ie. as y=value, or just the value).

Download solve_lin.mw

You could also get a so-called step-by-step solution shown for this class of linear problem.

This is a verbose illustration of how one could solve it by hand. (Maple's solve command has its own methodology, and I'm not sure whether you are actually asking how that works, internally.)

Download SBLSS.mw

Download simpl_ex.mw

I will submit a bug report against simplify.

The simple answer to Q1 and Q2 is no, unless you unprotect and reassign a new procedure to the global WARNING.

Q1. The attachment below shows one rough way to reassign to WARNING that will add the name of the calling procedure. (I just did a slight modification of a bit of a package I wrote for redefining userinfo to send its messages to a TextArea component.)

Q2. You could modify and extend that implementation to make command specific suppression possible. Since the procedure redefinition below has access to the name of the caller then that could be tested against a stored table/record. And so you use some name for storing that, eg. warnings[f]:=false or what have you. Alas I don't have time for that right now.

Q3. Likely yes, programmatically manipulating the saved .mw file and writing out to a new .mw file. But that approach would require time to implement.

Download WARNING_redefn.mw

Of course, you could modify or adjust that as needed. You could also unassign that table of results whenever convenient, etc.

Your syntax for calling the plot command seems quite wrong. I cannot imagine what you intended by l = 5*_8, except possibly as a typographical mistake where you intended the range l = 5..8.

Your syntax for invoking solve is wrong. That command does not take an argument of the form name=range.

Note that the error messages you showed do indicate these mistakes. You could also reference the allowed calling sequences of those commands on their respective help pages.

And there is not an explicit exact solution. Therefore I suggest calling fsolve instead here, to get a floating-point result.

Download rf_syntax.mw

I don't understand what your intention is, when you write "k=1..4".  The expression cos(k)*cosh(k)-1 does not have a real root for k between 1 and 4.

Here's one way to handle your examples,

Download subsindets_examp.mw

You could make that more general by having the name (eg. f) be an additional parameter.

Here are some answers.

note: I removed the call to assume. I never use assume if I can get by without it.  I prefer to get by utilizing assuming instead, since it can be used in a more targeted manner. Or, as in this case, one can get by with performing so-called simplification with side-relations (see below).

Download matrix_ops_Qs_ac.mw

The following approach is not fancy, but hopefully you'll find it understandable.

The basic idea here is to form a list of all the indices of the table, and then pare that down according to whether the corresponding values are NULL.

Download table_lk.mw

ps. There are even fancier ways, including some using newly introduced syntax. But the above should work in most/many old versions.

Please see the attached, which I believe is as much as can be recovered from your original attachment. (This is much more than the GUI itself recovers.)

Assignment2_ac.mw

There may now be four or five removed (invalid) 2D inputs:
1) just after, "We only need to consider the eigenvalues of the matrix A of the modelled system"
2) just before "From A__1 we have the first eigenvalue"
3) Just before, "The roots of the polynomium"
4) Just before, "To find the two eigenvalues we solve"
5) Just before, "The roots of the polynomium"

note: I think you might also have some misspellings, eg. "polynomium" for "polynomial", and "Luaponov" for "Lyaponov".

note: Of course, I will add this example to my previous bug reports of similar, reported problems.

note: There is some evidence that use of the Matrix palette in non-executable 2D Math might be related to the underlying GUI problem.

It looks as if there is no multiplication sign (or space, for implicit multiplication with 2D Input) before the brackets in the terms that look like,

   a(x+I*y)  ,  b(x-I*y) 

In that case those terms would be function calls (of a and b), rather than products.

Similarly the terms that look like bz , az would be just two-letter names, rather than products.

It's difficult to tell for sure because you haven't upload and attached your actual worksheet (green up-arrow in the Mapleprimes editor).