xCobaDoc.nb_21.html

6.1. ComponentArray and TableOfComponents

ComponentArray Generate a list of components
TableOfComponents Generate a list of components, with many more options

Arrays of components

The commands described in this subsection essentially generate lists of c-indices from free b-indices (or free a-indices through ToBasis). The basic command is ComponentArray,

In[273]:=

Out[273]=

${v_ ^0, v_ ^1, v_ ^2}$

NOTE: Up to version 0.6, the role of ComponentArray was played by a different function, called Components.

If the object to expand is a tensor (and only in this case), we can use a shorter notation

In[274]:=

Out[274]=

We can mix bases

In[275]:=

Out[275]=

Component indices are not expanded

In[276]:=

Out[276]=

${T_ (01)^ , T_ (11)^ , T_ (21)^ }$

We can specify which indices to expand

In[277]:=

Out[277]=

In[278]:=

Out[278]=

but c-indices are never expanded

In[279]:=

Out[279]=

The order of indices matters:

In[280]:=

Out[280]=

In[281]:=

Out[281]=

ComponentArray avoids clashes with dummy indices (notice the use of Scalar):

In[282]:=

Out[282]=

${Scalar[v_a^ v_ ^a] v_0^ , Scalar[v_a^ v_ ^a] v_1^ , Scalar[v_a^ v_ ^a] v_2^ }$

If we want more flexibility, we can use TableOfComponents. This function, whose syntax mimics that of the standard Mathematica Table, is much more flexible, but also slower. The reason for this is that TableOfComponents uses ToBasis internally, which performs many checks. Now we specifiy `iterators' on basis indices as additional arguments. If the specified index {a, basis} was already in the expression, this just tells the function when to expand it (i.e. in what order with respect to the remaining indices). If it was not present but a appeared as an abstract index, the system first turns it into a basis index and then expands it:

In[283]:=

Out[283]=

In[284]:=

Out[284]=

Notice how basis indices mimic the behaviour of Mathematica iterators. We have been able to expand an expression which contained only abstract indices. This is equivalent to doing

In[285]:=

Out[285]=

In[286]:=

Out[286]=

However, we cannot change the basis of a BIndex already in the expression

In[287]:=

Out[287]=

If we do not specify any index, the argument is returned unchanged (compare with ComponentArray):

In[288]:=

Out[288]=

In[289]:=

Out[289]=

${v_ ^0, v_ ^1, v_ ^2}$

The order is again important

In[290]:=

Out[290]=

In[291]:=

Out[291]=

As ToBasis is able to handle derivatives, we can include them in the arguments of TableOfComponents

In[292]:=

Out[292]//MatrixForm=

In[293]:=

Out[293]=

If we wanted to obtain this result from using ComponentArray, we would have to be much more careful.

Several vbundles

In[294]:=

Out[294]=

${{u_ ^(-1) v_ ^0, u_ ^(-1) v_ ^1, u_ ^(-1) v_ ^2}, {u_ ^1 v_ ^0, u_ ^1 v_ ^1, u_ ^1 v_ ^2}}$

These functions do not take the symmetries into account automatically, but we can simplfy

In[295]:=

Out[295]//MatrixForm=

Currently there is no function to construct a single component, because the notation must be nearly as long as the direct construction itself! Coba (see section 6.2) can be used to do that, in case the same component must be constructed for several different tensors.

Created by Mathematica (May 16, 2008)