You could also re-use your existing code, with a caveat:
It's not clear what you want to happen at the transition. I'm not sure whether you want either, none, or both of the animations to show at t=0. You could change the total number of frames to the odd number 141, say, to get either at t=0 (depending on a strict vs nonstrict inequality). You could also modify the `if` (nesting it, say) to display both at t=0, though I'd guess you might not want that.

(I'm supposing that you would not want to merge two separate animations which both had a t=0 frame.)

Download how_transition_ac.mw

The reason that it works in the procedure is that inside the procedure the (local) name x has been assigned using the set X, ie. lhs~(X). Once you get back to the top-level, outside your procedure, the global name x lacks that value.

Your subsequent top-level replacement could also be accomplished as (simpler, IMO),

    subsindets([dd], suffixed(x), ee -> ee(t))

I think that using globals is awkward, when not necessary. I prefer to use multiple return values, and have the substituted expressions be an additional return value. This would be my preferred approach.  elementwise_equal_ac.mw

Try this, for purely numeric integration:

evalf(Int(abs(1/(x - 2) + 0.5333 + 0.3333*x + 0.1333*x^2), x = -1 .. 1));

                         0.06041415825

By simplifying the integrand (which here sees that x>-1, x<1) before doing the symbolic integration the issue can be avoided.

value(simplify(Int(abs(1/(x - 2) + 0.5333 + 0.3333*x + 0.1333*x^2), x = -1 .. 1)));

                     0.06041419887

That symbolic integration of the simplified inert definite integral happens to produce a correct result and avoid the underlying symbolic problem, but I suggest you not rely on that technique, especially if you are willing to accept a solution with floats. Instead, I'd suggest you try to rely on the first approach I gave of performing purely numeric quadrature.

The following manipulation obtains the same erroneous negative result, and illustrates how it can go awry by, say, failing to split piecewise at every sign change in the integrand. (I used Maple 2022.2).

Download int_neg_ex0.mw

If you plot the integrand in H you can see that it has the wrong sign, for some values.

I will submit a bug report. [edit] It may already be fixed in the version under deveopment.

One way is to use an anonymous procedure.

If the operation involves a command that passes extra arguments at the end then your particular implementation of `&/` allows a terser solution.

Download infix_fun.mw

1) You could change the initial creation of A to,

   A := Matrix(11,11);

and then do your loop.

2) Or you could get rid of the loop altogether and create it as,

   A := Matrix(11,11,(i,j)->i+j-2);

3) Or you could just change the entry assigning line to,

   A(i,j) := i+j;

It happens because A2 is a Matrix, a mutable data structure.

The assignment inside your procedure makes A1 a reference to A. And Matrix A2 is not copied when it is passed in as an argument to the procedure call, so A is a reference to A2.

So your updates to entries of A1 are updates to entries of A, and thus are actually updates to entries of A2. This is part of something that is sometimes called in-place semantics.

If you don't want that behaviour then you can use copy semantics instead, by replacing the line that assigns to A1 as,

   A1 := copy(A);

Changing just that aspect of your example,

Download d_ac.mw

In-place semantics allow for reduced memory use, by not creating a copy unless necessary. This can be a useful and convenient default for mutable data structures; it can gain efficiency for large examples that do not require the copy (because, say, they might not need the original data preserved).

@zenterix How about using ExportMatrix to export purely numeric data to files? You could compare the timing by using (or not) binary (Matlab) file formats supported by that command.

If there are headers (containing nonnumeric data) for the rows or columns then you could save those separately. For large amounts of float data I suspect that it'd be more efficienct to export/re-import without headers (datatype=float[8], say), as Matrix or Array (not DataFrame or anything fancy).

You could generate the filenames in the parent process, and pass one into each Grid process.

Here's how your stated target can be found using collect, as well as some alternative metrics.

I also show an alternative result, which scores better than your proposed target on all four metrics shown.

Download crush_ex0b.mw

@zenterix 

If you keep/create your packages in the following pattern then the lib subdirectories get added to libname automatically upon relaunch.

  $(HOME)/maple/toolbox/mypackage/

where the .mla for that package is put in a subdirectory named lib.

You can also put the source under that directory.

And so all the source, along with the .mla, can be under that mypackage directory.

And similarly for mypackage2, mypackage3, etc.

In new Maple sessions the kernel will pick up the lib subdirectories for all such, and add them to libname.

The key here is putting them under this special location: whatever this returns,

  cat(kernelopts(homedir),"/maple/toolbox");

This approach removes the need to use any initialization file. Thus any tricky editing of an initialization file is wholly unnecessary.

And it lets you keep each package's source and .mla under its own directory. (Which you wanted, for github.)

The value of libname gets further augmented (in subsequent sessions) simply by adding another package in another such directory tree.

Side-note: You can also programatically create a self-installing file which unpacks any or all of .mla, .help, source, and build-scripts to the equivalent directory on someone else's machine. (This knows where to place these toolbox files regardless of operating system: Linux, MS-Windows, or OSX.)

This is the scheme Maple uses for its own add-on toolboxes. Why reinvent the wheel?

As documented on the procedure Help page, within a procedure a reference to a local gets only single level evaluation.

In contrast a declared global gets fully evaluated.

Here are a few notes:

Download local_eval_notes.mw

The problem is caused by the algorithm behind the (new to Maple 2022) default adaptive=geometric option.

You can get around this by supplying the option adaptive=true (or its shorter equivalent, merely the keyword option name, adaptive).

(I have submitted a bug report against this example.)

Download arcsin_ac1.mw

Yes, providing a .mla file (Maple Library Archive) and a .help file (Maple Help database) is a relatively common way to share one's data/procedues/modules/help-worksheets with other people.

It's up to you whether you also wish to provide the source code for your procedures/modules, or any special script that might read such into a session.

I suggest that you keep the .mla archive libirary files all in one common directory, and use the subdirectory structure for the various source files.

As for how to manage the subdirectories, I sometimes do it as follows:

I have my various packages' module (parent) definition files in a common location, eg.
    src/pack1.mpl
    src/pack2.mpl

The src/pack1.mpl file looks like this,

pack1 := module()
   export f1,f2;
   local f3;
$include "../pack1/src/f1.mm"
$include "../pack1/src/f2.mm"
$include "../pack1/src/f3.mm"
   end module;

And similarly for the src/pack2.mpl file.

All in all, I get the following

   lib/pack1.mla
   lib/pack2.mla
   src/pack1.mpl       # module defn
   src/pack2.mpl       # module defn
   pack1/src/f1.mm   # module member, eg. proc defn or submodule defn
   pack1/src/f2.mm   # proc defn
   pack2/src/g1.mm   # proc defn
   pack2/src/g1.mm   # proc defn

This way I only have to have that single top "src" directory in the include-path. The other files are picked up when I read either of the two parent .mpl files because I used relative names in the $include directives. I don't ever have to concern myself with "searching" for parent source files, or adding multiple locations to the include path.

And I only have a single location added to libname.

(Eventually I move the .mla files over to a ($HOME)/maple/toolbox subdirectory  on my machine, so that libname gets augmented automagically.  I seldom bundle them up as a package redistributable via the Maple Cloud or someone else's Maple GUI, but if I did I would never use a Maple workbook as the only copy of my sources.)

[edit] You might wonder why I bother at all with having the files in a "src" subdirectory. It's because I also have "doc" and "tst" subdirectories at those same levels, for documention&notes and for unit test files.

You can alter various aspects of this, to suit your taste.

Download 1d_numberline.mw

It's not the only way to get such an effect.

If you already have some existing, computed list of points (which does not simply include all the naturals up to some number), then the above code can be adjusted to get a few alternate appearances. [Thanks, dharr, for referencing this case.]

For example,

Download 1d_numberline2.mw

Your syntax for creation of Arrays for A and B is faulty. Your code creates them as lists, not Arrays.

Also the approach of using of a loop to repeatedly augment a list is inefficient. And you ended up with name t being assigned a numeric value, which then makes using the F formula awkward.

Here is one (of several) ways get it:

Download DFT_Test_ac.mw