A difference in sign:

Download int_cpv_ex1.mw

You have not provided your problematic module, so I'm going to guess.

This is not allowed in Maple 2026,

restart;
kernelopts(version);
   Maple 2016.2, X86 64 LINUX, Jan 13 2017, Build ID 1194701

M := module()
  local x;
  x := 5;
  export F := proc(x) sin(x); end proc:
end module:
Error, unexpected `export` declaration in `module` body

But it's ok in Maple 2020,

restart;
kernelopts(version);
   Maple 2020.2, X86 64 LINUX, Nov 11 2020, Build ID 1502365

M := module()
  local x;
  x := 5;
  export F := proc(x) sin(x); end proc:
end module:

You might consider,

restart;
kernelopts(version);
   Maple 2016.2, X86 64 LINUX, Jan 13 2017, Build ID 1194701

M := module()
  local x;
  export F := proc(x) sin(x); end proc:
  x := 5;
end module:

M := module()
  export F;
  local x;
  x := 5;
  F := proc(x) sin(x); end proc:
end module:

Perhaps the simplest is to store the data in a file.

If the data is in a Matrix, Array, or table then you could save it as a .m file. Or if it's a Matrix or Array you could export it to a file.

Then you could read (or import, if exported) that file back into your separate worksheet.

It's not quite clear (to me) from your Question whether you "table" might be an Matrix, Array, or table data-structure.

If you don't mind your worksheets being bundled together then you could also store both those and the data in a workbook. Or you could share a variable across them.

I really dislike making unnecessary assignments, since then the assigned symbolic names are no longer directly available for further symbolic manipulations (unless you also unassign, ie. wasting time and effort).

So, after what you had so far, you could do the following, if like me you prefer Qb11,etc remain unassigned. This does substitution instead of assignment.

eqs1 := Equate(lhs(eq1), rhs(eq1));

plot(eval(Qb11, eval(eqs1, [Q22 = 1, s = 1])), p = 0 .. 9);

plotting_elements_of_matrix_ac.mw

For your example, the rational factor of 1/3 gets distributed by a process within the Maple engine called automatic simplification.

That cannot be prevented through unevaluation, eg. it's not prevented by uneval quotes.

'1/3*(1-exp(-3))';

          1   1        
          - - - exp(-3)
          3   3        

So, about the best you can do here is turn some part(s) of the expression into a form that pretty-prints as you want it (even if it isn't the same value, internally).

Your example is rather short, and there are a few ways to accomplish such pretty-printing workarounds for it. Some of the approaches render slightly differently across versions. You didn't say which version you're using.

For example,

Download inert_autsimp.mw

You seem to expect that the condition x>=-4 implies only one explicit solution (for y). But that's incorrect. As the following plot illustrates, there are two y-solutions for each x>=-4.

plots:-implicitplot(x=subs(x=y,x^2+8*x), x=-18..5, y=-10..1,
                    rangeasview, size=[400,300]);

Perhaps you mean instead that y>=-4 ?  With that condition one may obtain a single, restricted solution. That can be accomplished either by utilizing assumptions or by supplying the extra condition in solve's first argument.

Download solve_restr.mw

Similarly, for y<=-4,

solve(x=y^2+8*y, y, useassumptions, parametric)
  assuming y::RealRange(Open(-infinity),-4);
           /                       [[                 (1/2)]]\
  piecewise\x < -16, [], -16 <= x, [[y = -4 - (x + 16)     ]]/

solve({x=y^2+8*y, y<=-4}, y, parametric);
           /                       [[                 (1/2)]]\
  piecewise\x < -16, [], -16 <= x, [[y = -4 - (x + 16)     ]]/

A Plot Component has a programmable property for the delay between frames.

You can programmatically construct, embed, and control the playing an properties of an animation inside a Plot Component. (see attachment)

You can even programmatically embed an animation which automatically starts playing, with your specified frame delay.

Ignoring some (usually small) rendering overhead, the frame-delay can be taken approximately as the reciprocal of the frame-rate -- accomodating also for the scaling conversion seconds vs milliseconds.

anim_auto_fps.mw

Somewhere I had a version of this which included play/stop/fastforward/etc Buttons below the Plot Component. I can't find it now -- it was years ago. I might have included a Dial for frame-rate/fame-delay.

Of course, this does not provide any way to alter the frame-rate for exporting to animated .GIF file. For that purpose all I know is the crude slowing down of an animation by duplication of certain/all frames.

Download Worksheet_1_implicit_acc.mw

You might also consider applying the print command to the procedure.

In recent versions you could also utilize fprintf with a new format to write out procedures with nice formatting and line-breaks. [edited] See Comment below for an example.

The text version does a step like,

  gen := (i, j) -> evalf(a(inits[j], i))

whereas your version does that like,

   gen := (i, j) -> evalf(a(inits, i))

Those are not the same. And that seems the central mistake.

In this attachment I also changed the call of evalf[4](...), slightly, so that the results are rounded to four digits while still computed at Digits=10 precision. It doesn't make a difference in this example, but using evalf[4] alone is unnecessarily innacurate in general; using that alone is not a great way to simply round results to four digits.

I also inserted an unassignment to name `a`  -- after it was assigned an operator earlier on, and before a subsequent rsolve call. (I had already done this earlier, but have now edited my Answer to mention it.)

Discrete_Dynamical_Models_2_ac.mw

ps. I also changed your Post into a Question.

If you omit both an explicit multiplication symbol as well as an intervening space then in 2D Input (in Maple 2017) the second brackets will get parsed as a function call.

In Maple the syntax allows for an addition or subtraction of the operator names. Eg,

   (sin + cos)(x)

gets parsed as  sin + cos  applied to argument x, and evaluates to sin(x) + cos(x) .

Also, a number (such as 11) applied to an argument evaluates to just 11 itself.

And so,

   (epsilon[3] - 1)( ... something ...)

gets parsed as  epsilon[3] - 1  applied to that something as argument. It gets parsed as a function call. And it evaluates to  -1  plus  epsilon[3] applied to that something.

This appears to be what has happened in your example, judging by your attachment.

If you do not like to see the explicit "dot" in the 2D Input then you could put a space between such brackets instead, in your Maple 2017. You can control whether such a space gets interpreted implicitly as multiplication as a user preference. See Tools->Options->Interface from the main menubar.

Using rsolve we can obtain exact formula for a[n] and b[n], and giving limit a reasonable helping assumption we can show both have limit sqrt(a[0],b[0]).

The formula N(n)=a*b/M(n) follows from the original pair of formulas. It can be used to remove either M(n) or N(n) from each recurrence relationship obtained from each of the two formulas.

I am naming things as M(n),N(n),a,b  but you could as easily name them a(n),b(n),a0,b0 respectively.

Download recur_fun.mw

If you wish to generate numeric results (exact, or floats) for some concrete pain of initial values a,b then you could pass rsolve its makeproc option, or convert those arctrigh results to expln so as to avoid small imaginary artefacts.

For example, using the above formulas GMe and GNe above for a[n] and b[n],

seq(simplify(eval(convert([GMe,GNe],expln),
                       [a=1,b=2])),
         n=0..4);

             [3  4]  [17  24]  [577  816]  [665857  941664]
     [1, 2], [-, -], [--, --], [---, ---], [------, ------]
             [2  3]  [12  17]  [408  577]  [470832  665857]

evalf([%])[];

    [1., 2.], [1.500000000, 1.333333333],
    [1.416666667, 1.411764706], [1.414215686, 1.414211438],
    [1.414213562, 1.414213562]

Those agree with the float values that vv obtained purely numerically.

There was a corruped, unclosed <Equation> in the XML (raw text of the .mw file).

Closing that up I get the following: see attached. Please check that it contains (almost all) you expect.

The missing equation is an input, likely a few lines after the text, "So, the answer introduced lines above becomes:".

MyMinitCourseComputerAlgebraForPhysicsPart2_ac.zip

It is a shame that the GUI itself cannot recover your worksheet, while it can be done manually with an external text-editor.

Use the * key (shift-8 on my keyboard) for normal multiplication, not the lower-dot which denotes noncommutative multiplication.

If I rerun your attachment then I get a NULL result from solve. But after I change the lower-dots (periods) to * then your worksheet behaves as follows.

Download mapletrial_ac.mw

Your attachment was last saved in Maple 18, so I marked your Question accordingly.

Augmenting a list in a loop (as you did as the later stage of your procedure, to create primelist) is inefficient. You could use seq instead, to run through L.

Consider:

restart;
Eratosthenes := proc(N::posint) 
local L, primeslist, n, k; 
description "Calculate all primes less than or equal to N"; 
L := Array(2 .. N, i->true); 
for n from 2 to trunc(sqrt(N)) do 
if L[n] = true then 
for k from n while k*n <= N do 
L[k*n] := false od; fi; 
od; 
primeslist := NULL; 
for n from 2 to N do 
if L[n] = true then 
primeslist := primeslist, n fi; 
od; 
primeslist;
end proc:

Eratosthenes(32);

       2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31

CodeTools:-Usage(Eratosthenes(2^20)):
memory used=25.24GiB, alloc change=39.49MiB,
cpu time=35.61s, real time=35.68s, gc time=21.98s

nops([%]);

                82025

restart;
Eratosthenes2 := proc(N::posint) 
local L, n, k; 
description "Calculate all primes less than or equal to N"; 
L := Array(2 .. N, i->true); 
for n from 2 to trunc(sqrt(N)) do 
if L[n] = true then 
for k from n while k*n <= N do 
L[k*n] := false od; fi; 
od; 
seq(`if`(L[n]=true,n,NULL), n=2..N);
end proc:

Eratosthenes2(32);

       2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31

CodeTools:-Usage(Eratosthenes2(2^20)):
memory used=183.78MiB, alloc change=20.00MiB,
cpu time=3.49s,real time=3.50s, gc time=1.54s

nops([%]);

                82025

You might rewrite the first part of your code to use hardware integers and then Compile it, or run it in a inner procedure under evalhf. I haven't done either, but I wouldn't be surprised if you could get a further factor of 5 or more speedup. (It could vary according to the kind of data structure used to return the result: eg. hardware Array or expression sequence/list.)