I used text math input, finding parenthesis is very difficult sometimes.

It would be very nice if parenthesis were color coded OR coloring of the texted was based on parenthetical depth.

E.g.,

display(plot(something(or another)))

with(IterativeMaps): with(ImageTools):

BP := proc(f, S, I, m, M, xm, xM)
    local L;
    L := Bifurcation([x], f, S, m, M, xmin=xm, xmax=xM, height=800, width=1300, iterations=I+500):
    ArrayTools:-Dimensions(L):
    ColouringProcedures:-HueToRGB(L):
    Embed(L);
    L:    
end proc:

F := []:
f := [sign(r)*ln(abs(r))*cot(x)*(log[2+abs(r)](abs(x)) - x*sin(x))]:

F := [op(F), BP(f, [0.1], 10000, -10, 10, -15, 15)]:
F := [op(F), BP(f, [0.2], 10000, -10, 10, -15, 15)]:

F := [op(F), BP(f, [0.3], 10000, -10, 10, -15, 15)]:

F := [op(F), BP(f, [0.4], 10000, -10, 10, -15, 15)]:

I was trying to create some images of some bifurcations. I can't seem to create an animation from the images.

Also, Embed works great but each call to BP overwrites the previous image(rather than creating a new image)... Preview works but doesn't scale the images up properly.

I have a recursive function that spits out recursive formulates "evaluated inertly" so bascially it produces a formula simply like a symbolic formula(doesn't reduce the addition of values though).

What I would like is to color code each recursive step

e.g.,

F := proc(n)
    local i,k:
    if n <= 0 then return 1; end if:
    F(n-2) %+ F(n-1):
end proc:

F(5);

value(F(5));
 

so I would like to cover each part of the recursion differently so it is easier to see, maybe even use the previous colors so one can visualize the nestings of the recursion. (e.g., F(n-2) takes the previous formals color and tweaks it towards the red and and F(n-1) takes the porevious formulas color and tweaks it towards green)
(this would then pass an RGB value that(default, say blue) to the functions above).

Any way to accomplish this?

I have a formula that essentially is a m-order sum over a totally ordered set(the integers).

sum_{n_1=1)^{n_0} ... m times ... sum_{n_m=1}^{n_{m-1}}

It may be a little confusing but essentially it is just summing over all monotonic lidyd of size m of [1..n_0]

e.g., if n_0 = 4 and m = 3 then

1 2 3

1 2 4

1 3 4

2 3 4

Does maple have a convient way to do this? Ideally some function like osum(..., i=1..n_0, m)

where i is a multi-index(just the ordered list here so I could access i[1] the smallest, value, i[2] is the next largest, etc).

so I can get inert operations but what about parenthesis and built ins?

add(k,k=1..5)

I can't remember the specific code but what I was getting was something like

1 + 3 + 4 + 5 + 6 /4

rather than (1 + 3 + 4 + 5 + 6)/4

and the parenthesis was not showing up and I couldn't use things like add or mul in an inert like form(I think I had to write a loop).

What I had to do was multiply by 1 inertly and then it added the parenthesis.

If I could add inert parenthesis it would have solved the problem and also get built in functions to be inert but only on their ineternal operations.