MaplePrimes - answers and comments on Question, How to extract triangular matrix into a vector (column)?

First question

Adri van der Meer — Tue, 13 Nov 2012 16:30:34 Z

To create a column vector of the none zero entries in "UpperTriangle(m) you can do:

 with(ArrayTools):
m:=<1,2,3,4|3,2,1,0|x,y,z,z0|a,a,a,a|b,b,b,b>;
lscol:=<seq(1-AddAlongDimension(m,2)[i],i=1..4)>;
m:=<m|lscol>;
M := UpperTriangle(m);
V := Vector( convert( select( x -> x<>0, M ), list ) );

I see no way to quickly reconstruct the upper triangle matrix form the vector V

Reconstruction of M

Adri van der Meer — Tue, 13 Nov 2012 20:53:42 Z

...so I make a procedure to do this:

RestoreMatrix := proc(r,c,V)
local M, i,j,k;
M := Matrix(r,c):
k := 1:
for i to r do
   for j to i do
     M[j,i] := V[k]:
     k := k+1
   end do
end do;
for i from r+1 to c do
   for j to r do
     M[j,i] := V[k];
     k := k+1
   end do
end do;
return M
end proc;

RestoreMatrix(4,6,V);

Matrix constructor

acer — Tue, 13 Nov 2012 23:15:02 Z

@Adri van der Meer The custom do-loop can be faster, but just for fun,

G:=(m,n,W) -> Matrix(m,n,(i,j)->`if`(i>j,0,W[(i-1)*n-((i-1)*(i)/2)+j])):

G(4,6,V);

Indexing function

Adri van der Meer — Thu, 15 Nov 2012 21:09:02 Z

@acer , I also tried to find an indexing function, but I didn't succeed.
But your quick solution doesn't work:

restart;
m := LinearAlgebra:-RandomMatrix(4,6):
M := ArrayTools:-UpperTriangle(m);
V := Vector( convert( select( x -> x<>0, M ), list ) ):
G:=(m,n,W) -> Matrix(m,n,(i,j)->`if`(i>j,0,W[(i-1)*n-((i-1)*(i)/2)+j])):
G(4,6,V);

by columns of M

acer — Thu, 15 Nov 2012 23:16:21 Z

@Adri van der Meer Sorry, perhaps I didn't notice that V was constructed by reading along columns of M. So naturally you would want to reconstruct it by laying down entries from Vector V in the same way.

Is this a fix-up, to lay down the Matrix, columnwise, from given Vector V with that interpretation?

Gr:=(m,n,W) -> Matrix(m,n,
                     (i,j)->`if`(i>j, 0,
                                 W[((j-1)*(j)/2)-`if`(j>m,
                                                     (j-m-1)*(j-m)/2, 0)+i])):

I would guess that a do-loop could be faster than such an indexing function due to the hit from calling `if`(i>j,...) on all entries (because with nested loops the upper value for the inner loop's index can be a function of the outer loop's index). And indeed, your procedure performs faster.