Download stacklimit.mw

L := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:

[seq(L[2*i-1]..L[2*i],i=1..nops(L)/2)];

        [1 .. 2, 3 .. 4, 5 .. 6, 7 .. 8, 9 .. 10]

I don't see how your question makes it clear whether you want the braces or their contents to be colored. So I have to guess. I guess it's the contents. (If it's the brackets -- or both -- then I don't see that you've sensibly described how to color it.)

It's not clear exactly how you want the colors "tweaked" with each iteration. But you might adjust this to taste:

Download color_recur.mw

[edit] Transitioning from color to color can be a subtle business. You might prefer the "Lab" colorspace rather than "RGB" since the former grades perceptually evenly (RGB runs evenly in terms of the monitor output, not perceptually). Two colors whose midpoint isn't some gray near the white point may also be nicer. Just let me know.

Also, the braces can be colored, but if that's desired then I'm not understanding the target details.

You can use the command evalf to compute that single floating-point arctrig call.

evalf[15](arccos(0.62))

             0.902053623592525

The command factor can be used to factor this polynomial.

p := x^5-11*x^4+27*x^3+67*x^2-320*x+300:

factor(p)

                       2        2
        (x + 3) (x - 2)  (x - 5) 

Are you trying to compute approximations of only the real roots, or also complex roots?

You still haven't shown your larger example where computation takes too long. is it a polynomial sysyem?

How much accuracy do you want?

The eliminate command can (fortuitously) be used to see that d[1] also has a special value. And c[0] and d[0] can be recognized by the trivial eq[7] and eq[8]. But RootFinding:-Isolate would also find the real solutions without that finesse.

There are various other possible apporaches (using calls to solve, eliminate, evalf, etc). But if you are only looking for the real roots of a polynomial system with exact coefficient then Isolate has the advantage of attaining a target accuracy without so much fuss over having to raise working precision to avoid roundoff error.

Download poly_system.mw

So, you have four different instances of the pair of tables Beams and Beams2?

Why not store them with one more (cheap) layer of indirection? That is to say, have four differently named parent tables (eg, BeamsTable[1], BeamsTable[2], ...) each of which contains their own distinct pair?

BeamsTable[1][Beams] is one, from a pair
BeamsTable[1][Beams2] is the other, from that pair

Or you could name the distinct parents BeamsTable1, BeamsTable2, etc. That could mean slightly less effort in storing them, with completely separate calls.

You don't even need to use different .mla files. You could utilize just one.

One of the points I tried to convey in my response to your previous (related) question is that you need to manage the global namespace of your Maple sessions. I likely was not clear enough about that. It should be done through deliberately assigned names (in Maple), and not attempted as a byproduct of external filenames/locations.

Saying it another way: don't store different things under identical names in .mla files if you want to retrieve them as distinct things. Trying to leverage the file system for that (provided that you don't need more than one distinct access per restart) could be accomplished, but it's really not a good way to go about it. And more general access (within restart) is going to present some near-impossible scenarios.

nb. In your earlier thread I did not mention storing in plaintext (input Maple notation), because I assumed that you would not want any solution which incurred the overhead of reparsing the language input code -- per session.

What precisely do you mean? You haven't given any example to illustrate. The LinearAlgebra:-Eigenvectors command already returns both vectors and values, so you must mean something else. I will guess.

Are you trying to say that you like the syntax where the number of computed and returned objects depends on the number of entries in the sequence on the left-hand side of the assignment statement? That is, where the particular computation (with the same right-hand side of the statement) varies according to whether the assignmnent is,
  (a,b) := ....
or
  a := ....
The former computes and returns two items (eg, both the eigen-vectors and values), while the latter computes just one (eg. only the eigen-values).

Personally, I find that syntax to be poor and disjointed. I am glad that no other commands have taken up this un-Maplelike syntax (as any further cloying attempt at Matlab emulation). I suppose it's a matter of personal preference.

For those interested, that functionality is implemented using the _nresults item in the context of procedure parameter-processing.

MTM is now a regular package of Maple (alone), rather than a toolbox. (Documentation of connectivity with Matlab is not great. But the MTM computational commands are available.)

Is this the kind of thing that you're trying to accomplish? (I looked at only ev7...)

I used Maple 15.01, since your attechment seems to have been last saved in Maple 15.

Download MaplePrimesacer_ac.mw

restart;

RR := Record( 'center' = [ 0, 1 ], 'radius' = 3,
              'mytable' = table([foo=bar]) ):

LibraryTools:-Save(RR, cat(kernelopts(homedir),"/mapleprimes/MyLib.mla"));

And now, you only need that .mla to be within libname in order to access the Record assigned to name RR,

restart;

libname:=cat(kernelopts(homedir),"/mapleprimes/MyLib.mla"),libname:

eval(RR);

    Record(center = [0, 1], radius = 3, mytable = TABLE([foo = bar]))

RR[center];

                         [0, 1]

entries(RR[mytable]);

                          [bar]

And if you wish you could set libname in your own initialization file, or with an option to your launcher. Or you could even utilize a .mla location such as (for example!),
   cat(kernelopts(homedir),"/maple/toolbox/XXX/lib")
so that the kernel prepends that to libname automatically.

So, in your equation is y=earnings and x=sales? If so then how about using those names in the equation?

Below I take more steps than is completely necessary, to try and make the process a bit more understandable.

One of the key commands I use here is eval, as a means of subsitution. There are several other equally good ways to go about these questions. For example you could set up operators (procedures) in instead of using eval.

Download eqnplot.mw

The parameters in an Explore call must be names.

It looks like you have assigned numeric values to names a and b.

explore_jamet.mw

The procedure getFnumer is set up to handle expressions of type `+`, but it is being sent an equation of type `=`.

Perhaps you wanted it to handle (lhs-rhs)(df) in that case?

But it would be much better if you described clearly what getFnumer is supposed to do.

restart;
sys:={3*x+5*y=21, -2*x+y=-1}:

sol:=fsolve(sys);
          
           sol := {x = 2., y = 3.}

eval([x,y],sol);

                  [2., 3.]

eval(<x,y>,sol);

                    [2.]
                    [  ]
                    [3.]

eval(x^2+y^3,sol);

                     31.

eval(x,sol);

                      2.

and so on.

Or, if you want to utilize LinearSolve from your system,

A,B := LinearAlgebra:-GenerateMatrix(sys,[x,y]);

                 [-2    1]  [-1]
         A, B := [       ], [  ]
                 [ 3    5]  [21]

LinearAlgebra:-LinearSolve(A,B);
                    [2]
                    [ ]
                    [3]

All three examples work in Maple 2016.0 (and 2016.2, and 2019.2, which is all I checked).

In particular, the first example works in Maple 2016, ie. using the ListBox works without need for manual handling/parsing.

The difference is that in the later releases the code behind the ListBox contains this fragment:
    ':-handlers'=[r=proc () option builtin = parse; end proc]
Additionally, if the first example only is executed and saved in Maple 2019.2, then upon being opened in Maple 2015.2 that exploration works without re-executing the Explore call (although you'd first want to assign val as done originally).