There are many ways to do that. Which way you use may depend on

1. what you want to do with the saved data (read it by eye, re-use it later in the program, etc.)
2. what order you want to access the saved data (randomly, last-in-first-out, first-in-last-out, all at once, etc.)
3. how much memory you have (can the main memory hold the data? do you need to write to disk? etc.)

The fundamental data structure for this---the one that is most versatile in most of the above cases---is called a table. It is so fundamental that it often does not need to explicitly declared.

Let's say you have this loop:

for k from 1 to N do
    ... some computations to create or modify a vector V ...
end do;

Add one line:

for k from 1 to N do
   ... some computations to create or modify a vector V ...;
   MySavedData[k]:= copy(V)
end do;

At any later time in the program, if you want to retrieve the vector for, say, k=50, do

W:= MySavedData[50];

or, if it is safe and convenient to overwrite V at this point, do

V:= MySavedData[50];

You may need to do the retrieval with copy(MySavedData[50]), depending on whether you intend to modify the vector again and whether you wish to also preserve the original.

Tensor and TensorSort are locals of the Physics module, not exports. You can access all module locals with the :- syntax by giving the command

kernelopts(opaquemodules= false);

at the top level. Many people include this command in their initialization file. After this command, you need to access them as Physics:-Tensor and Physics:-TensorSort, even though the Physics prefix may not appear in the original code.

The problem is too easy to use a computer for. There are 6 columns and only 5 dimensions, therefore, they are not a basis and the matrix is not invertible. There is no computation required to do the problem other than simply counting to 6.

The reason that it is taking so long is that it is first computing Eigenvalues(A) in exact arithmetic, and then applying evalf to that; rather than working in floating point from the start. With the all-in-floating-point approach, it is possible to work at Digits = 25 and get the eigenvalues of a 200x200 matrix in reasonable time. And, as acer suggests, it will be much faster still at Digits = 15.

I hope these examples explain everything. If not, please ask for clarification.

restart;
Digits:= 25:
with(LinearAlgebra):
A:= RandomMatrix(50,50):
Af:= Matrix(A, datatype= float):
CodeTools:-Usage(assign('E1', Eigenvalues(Af)));
memory used=349.99MiB, alloc change=0 bytes, cpu time=2.03s, real time=1.98s
CodeTools:-Usage(assign('E2', evalf(Eigenvalues(A))));
memory used=0.93GiB, alloc change=0 bytes, cpu time=7.38s, real time=7.20s
CodeTools:-Usage(assign('E3', Eigenvalues(A)));
memory used=341.92MiB, alloc change=0 bytes, cpu time=2.20s, real time=2.14s
CodeTools:-Usage(assign('E3', evalf(E3))):
memory used=0.59GiB, alloc change=0 bytes, cpu time=5.06s, real time=4.92s

So the time for E2 is the sum of the times for the two steps of E3.

Norm(sort(Re(E1)) - sort(Re(E2)));
                                    -21
                           3.4 10   
Norm(sort(Im(E1)) - sort(Im(E2)));
                                    -21
                           2.5 10   
Norm(E2 - E3);
                               0.

So E1 and E2 are approximately equal in values; whereas E2 and E3 are identical.

A:= RandomMatrix(200,200, datatype= float):
CodeTools:-Usage(Eigenvalues(A)):
memory used=16.58GiB, alloc change=24.00MiB, cpu time=108.56s, real time=104.13s
Digits:= 15:
A:= RandomMatrix(200,200, datatype=float[8]):
CodeTools:-Usage(Eigenvalues(A)):
memory used=401.12KiB, alloc change=0 bytes, cpu time=219.00ms, real time=484.00ms
A:= RandomMatrix(2^11, 2^11, datatype= float[8]):
CodeTools:-Usage(Eigenvalues(A)):
memory used=32.23MiB, alloc change=32.00MiB, cpu time=26.20s, real time=16.11s

It is obvious that there is linear dependency because the number of vectors (6) is greater than their dimension (5). It remains to find a dependency relation.

Download RREF.mw

An alternative to the explicit option is to apply allvalues to a result returned by solve which contains RootOfs.

solve({x=k/4,y=-k/3,z=3*k/8,2*x^2+3*y^2+4*z^2=9},{x,y,z,k});
allvalues(%);
 

You wrote:

I will have to draw some tick marks on for r=0 and r=1, in Inkscape. I don't know why there isn't an (obvious) option to have tickmarks but not lines, or to move the lines so that they look nice.

No need to use another program. The tickmarks and the gridlines can be specified independently. So you can get your r=0 and r=1 tickmarks like this:

Download polarplot.mw

The plot options are not obvious because there are so many of them. I found this solution on page ?plot,axis.

You need to make it so that there is no tickmark on the radial axis that is equal to the full length of the axis. In this case, we need to remove the tickmark at r = 1. We do this with the axis[radial]= [tickmarks= ...] option. The other options below are to make the plot otherwise exactly like in your post, which I assume you did with the menus.

Download polarplot.mw

Download trigrad1314.mw

I made a minor change to deal with some of the long display labels. Here's a repost of the worksheet with the new code and some new examples. As for colored labels, I think something may be possible along those lines: colors (and other formatting information) can be encoded into names. I'll think about it.

Download FunctionTree.mw

Your expression for the integrand has unbalanced parentheses. I think you're missing a left parenthesis "(" at the very beginning. Once you repost a correction, I might be able to help you more. But I think that it's unlikely that you will get a symbolic answer.

The command is plots:-listcontplot(M, contours= [$1..20]). But you need to lay out your points in a grid form, which involves some sorting and approximating. I vaguely recall seeing a tool for this a many years ago. I will look for it.

Does the error occur in CalculateMatrix or after? Put a print statement after the CalculateMatrix call to find out.

It is a system of linear equations. It would be much more efficient to solve it with matrix operations (i.e. LinearAlgebra:-LinearSolve). Would a floating-point solution be acceptable? That would use much less memory.

You can convert the arrows, or anything else, to Cartesian coordinates, and put them on a polar plot like this:

Download polarplot.mw

Use Sum (with a capital S), instead of sum, and you will get the answer that you expect.

I have no idea what that escaped variable _O and the rest of that huge mess represents. Surely the result of differentiating the lowercase sum is a bug. However, I will note that the fault lies with sum, not diff, because you get a nearly identical mess if you just do the derivative in your head and enter

sum(sin(theta[j](t))*cos(theta[j](t))*diff(theta[j](t), t), j= 1..i-1);