Is this the kind of thing you're trying to accomplish?

note: I realize that I could have used mod (or iquo,irem), to handle your integer examples. But I wanted to give you something that you might also use for floating-point angles. I'm not sure how you plan to use any results, however...
 

Download QuestionMesPrincipale_ac.mw

You have the code,

for j from 1 to m-1 do
  for i from 0 to n-1 do
   u[i,j+1]:=(9*u[i-1,j]+14**u[i,j]+9*u[i+1,j])/16-u[i,j-1];
  end do;
end do:

That inner loop starts at i=0, but the lower bound of the first index of array u is 0, so you have an error when that loop tries to access u[i-1,j]. That index value becomes i-1=-1 when i=0, and is less than the lower bound 0. And so that access attempt is out-of-bounds. It's trying to access an element of u which does not exist. Perhaps you intended something like,
  for i from 1 to n-1 do
instead.

There is also an insteance of [i]/10 in the code. But [i] makes a list. Your code tries to add that to scalar values. Did you really intend for that? Perhaps you intended just i/10 instead?

There is also an instance of 4**u[i,j] in the code. The double-asterisk is syntax for powering, eg.  x**2 = x^2.  I suspect you intended just 4*u[i,j].

You could simply use mul to multiply together the finite (and concrete) number of terms, instead of stuffing in unevaluation quotes to try avoiding premature evaluation under product.

note. You could also use just Matrix(3,f) instead of Matrix(3,(i,j)->f(i, j)). And the entries are already floats, so you don't need to wrap it with evalf.

Download rzarouf_ac.mw

Is this the kind of 2D Input (from palettes) that you'd care to manipulate with the Logic package?

Download Logic_2DInput.mw

note: You can unwith(L) if you subsequently need to turn off L's rebindings, for other inputs. Also, you can always utilize the original globals in prefix form, eg. :-`not`(a) , :-`or`(a,b) though it's more wordy.

[edited] It might be suitable if 2D Input of the relevant items in the palettes got interpreted directly as the corresponding Logic package exports if that package were loaded. That's what loading the small module L provides.

In your Question's text you stated that you want to change it, "...by replacing  vin/Iout with omega0*Lm". But then later you showed the attempt,

   eval(sol1, vin/Iout = omega*Lm)

which has omega rather than omega0. I'm going to proceed as if that attempt were a typo.

The algsubs command can perform that initial substitution.

Download jrive_ex4.mw

I suggest that you double-check all your formulas.

I fix that kind of error by using a full colon as statement terminator.

It's slightly difficult to see exactly what your after, since s does not appear in your expression assigned to V, and that expression also contains a term R1_R2. I'll proceed below as if those are mere typos.

Perhaps it is something like the following?

Download jrive_ex3.mw

The andmap's purpose here is to bail (returning false) upon the first entry discovered as false. That's for efficiency.

But that could be done at both levels, here, ie. per equation as well as per soln value. In general that's even more efficient, as it would return the single false result as soon as any one instantiated equation were found to be false.

Download andmap_ex.mw

As fun bonus, there happens to be no seq variable in play, to be declared local...

Download jrive_ex.mw

Note what happens without the sort (I have to do it in a fresh session, since the sorted result in the session above is subsequently obtainable without it...).

Download jrive_ex2.mw

ps. If you have more involved examples then please show them up front in your Question.

If you merely use single right-tick uneval quotes (As Carl's suggested) then subsequent full evaluation of the resulting plot structure can lead to inadvertant and undesirable evaluation of assigned names in the textplots.

That can include the scenario where you pass the textplot(s) to plots:-display as a subsequent programmatic merging with plots computed only later.

That can make merely using uneval quotes a somewhat problematic approach. Too few layers of quoting and your code might accidentally evaluate the quoted expressions. Too many layers and some quotes can undesirably appear in the rendering. Too tricky, and fragile if mixed with later revisions to the overall code.

Passing the resulting assigned textplot structure around as eval(P,1) is possible, but that too can get complicated and onerous -- depending on later code changes.

Instead, your could use Typesetting:-Typeset to get the textplots, with much better resistence to such unwanted subsequent evaluation. Basically, it's just going to be more robustly useful in such a case that you don't want any part of the "text" to be subsequently, accidentally evaluated. You only have to focus on its construction, and not on how you use/pass it later.

In the examples below, the green text survives as intended, while the red text goes wrong due to inadvertant evaluation.

Download textplot_TT.mw

nb. If your expression is first assigned to some name, eg.  foo:=expression , then you might need either,
   Typesetting:-Typeset(Typesetting:-EV(foo))
or,
   eval('Typesetting:-Typeset'(eval(foo,1)))
etc, since Typesetting:-Typeset has special evaluation rules (to prevent automatic evaluation) on its first parameter.
textplot_TT_2.mw

A call like,

   DocumentTools:-GetProperty("ComboBox0", value);

will return the currently selected item in the Combo Box embedded component with that ID.

The command parse would turn that string into the global instance of a name (if valid as such).

CB_ex1.mw

There are examples of this kind of use of GetProperty on this Help page. (That page was the very first hit, when I entered ComboBox in the Help Browser's search field.)

The parse command is not specific to embedded components. You could also be more verbose with, say, convert(str,name), btw.

An even more typical scenario for such use of parse is getting user-supplied numeric values from a TextBox embedded component. In that case, the Help page's main example actually uses parse, which is helpful. In the case of a ComboBox any programmatic contextual switching could be string-based as well/easily as name-based, by which I mean that parsing to a name isn't so inherently useful because the choices were already hard-coded and known the code author.

I was able to recover the following. Please check it over.

There might be an equation or Matrix input missing after the line containing, "Til at starte med bestemmer vi", and another after the line beginning, "Vi kan bestemme". And I'm not sure whether the very first opening Section should contain all other Sections (you might need to adjust).

Auto_regne_dokument_acc.mw

This kind of curruption problem seems to be less frequent with Maple 2023. You might want to try that upgrade, if available to you.

In any event, I suggest that you try to make regular backups -- even if that means saving to separate files, manually.

The z that is the named parameter of your procedure,
    v := z -> functionList[1]
has nothing to do with the global name z that is in the expressions in the set. That's why your attempt does not succeed; invoking that procedure does not replace the z in the expression.

Here are two ways, the second a correction to your procedure-building approach, and the first a simpler approach using eval.

Download unapp_ex.mw

Is this one of the kinds of animation of the curves that you mean?

See attachment for animation of t vs x(t), t vs y(t), with all three playable together and axes aligned. Adjust as wanted.

caring_phase_pemanenan_predator_dgn_parametersesuai_jurnal_ac.mw

There seem to be quite a few "corner cases", what with automatic-simplification, GUI rendering quirks, etc.

(I did this quickly, without cleaning it up. Check for mistakes...)

Download example_2_acF.mw