@Alger Don't use storage= sparse. For what I showed to work, you must use shape= band[1,1]. That will also automatically set storage= band[1,1]. If you add storage= sparse to that, it'll override the storage= band[1,1], and the wrong compiled solver will be used. It'll use SparseIterative (NAG procedures hw_f11zaf, hw_f11daf, hw_f11dcf). The direct band matrix solver is CLAPACK procedures hw_dgbtrf_ and hw_dgbtrs_.

@FDS Note that inside the procedure MyProc, all of the parameters are scalars, and all of the arithmetic is scalar. And if you were to call it via MyProc(...), then all of the arguments would need to be scalars also. But if you simply change the call to MyProc~(...), then any subset of the arguments can be vectors as long as they're the same length and orientation (column or row). If you do it this way, then there's no need for loops or seq; that's all done behind the scenes by using the little ~. The same can be done using lists instead of vectors, though there's no benefit to doing that.  

Does your coefficient matrix have a special sparsity pattern, such as banded or tridiagonal? 

@vs140580 My guess is that you're trying to change the vertex labels in a graph produced by my procedure for the lexicographic product of graphs, which you very recently asked about in another thread. That procedure can be easily modified to produce string vertex labels. You just need to change

(nprintf, "%a:%a")

to

(sprintf, "%A:%A")

It's in the line after the line with GT:-Graph.

@acer You're right; my mistake. But this'll produce row vectors, (FWIW):

<1 | A>[1];
<A | 1>[1];

@moh111 Here it is:

PowerOfT:= proc(e)
    evalindets(
        e, 
        specfunc(T)^{-2, -1, 2},
        proc(e) local T, p;
            (T,p):= op(e);
            if p = 2 then (applyop(`*`, 2, T, 2) + applyop(0, 2, T))/2
            elif p = -2 then -2/(applyop(`*`, 2, T, 2) + applyop(0, 2, T))
            else -1/e
            fi
        end proc
    )
end proc
:           
ProductOfTs:= proc(t) 
local Ts, NotTs, n, a, b, x;
    (Ts, NotTs):= selectremove(type, [op](t), specfunc(T));
    n:= nops(Ts);
    if n < 2 then t
    elif n=2 then 
       (a,b):= op~(2, Ts)[];
       x:= op([1,1], Ts);
       mul(NotTs)*(T(x, a+b) + T(x, abs(a-b)))/2
    else error "product of 3 or more Ts not handled"
    fi
end proc
:
Ttrans:= proc(e)
    evalindets(
        PowerOfT(frontend(expand, [e])),
        `*`,
        ProductOfTs
    )
end proc
:
p := 8*T(x, 7)*T(x, 2)+4*T(x, 5)*T(x, 1)+6*T(x, 3)*T(x, 3)+7*T(x, 1)*T(x, 4);
                                                          2
    p := 8 T(x, 7) T(x, 2) + 4 T(x, 5) T(x, 1) + 6 T(x, 3)  + 7 T(x, 1) T(x, 4)

Ttrans(p);
               15                                            
   4 T(x, 9) + -- T(x, 5) + 5 T(x, 6) + 2 T(x, 4) + 3 T(x, 0)
               2                                             

        7        
      + - T(x, 3)
        2        

@acer Or, either of

<1 | A>;
<A | 1>;

@FDS The return is optional when it's the last statement before end proc.

@Carl Love Here's an option that you may prefer because it makes them prettyprint upright with no quotes at all:

subsindets[2](E, symbol, `#mo("%A");`, nprintf);

@vs140580 Like this:

subsindets(E, symbol, convert, string);

@moh111 Can we assume the following?:

1. In any given expression containing these functions to be simplified, the first argument (shown as x in your example) will the same throughout the expression?
2. No term will have a product of more than 2 T functions?
3. The only possible exponents on T functions are -2, -1, 0, 1, 2?

If we can assume those, it'll be quite easy. If not, it'll be more complicated, but not very complicated.

@lcz Go to help page ?updates,v2022.

@vs140580 Well, you could give my Answer in the other thread a vote up. That's the main Answer, not the Reply.

@MANUTTM You shouldn't use square brackets [ ] or curly braces { } as a replacement for parentheses (aka round brackets) ( ) for grouping and order-of-operations control in algebraic expressions. You'll need to go through the whole worksheet and change those to parentheses.

@vs140580 In the code in question, I used Maple 2022 syntax for local variable declarations. I just posted a retrofitted revision of the code in the other thread.