149 lines
5.0 KiB
Plaintext
149 lines
5.0 KiB
Plaintext
@q $Id: rfs_tensor.hweb 741 2006-05-09 11:12:46Z kamenik $ @>
|
|
@q Copyright 2004, Ondra Kamenik @>
|
|
|
|
@*2 Row-wise full symmetry tensor. Start of {\tt rfs\_tensor.h} file.
|
|
|
|
Here we define classes for full symmetry tensors with the
|
|
multidimensional index identified with rows. The primary usage is for
|
|
storage of data coming from (or from a sum of)
|
|
$$\prod_{m=1}^l\left[g_{s^{\vert c_m\vert}}\right]^{\gamma_m}_{c_m(\alpha)}$$
|
|
where $\alpha$ coming from a multidimensional index go through some
|
|
set $S$ and $c$ is some equivalence. So we model a tensor of the form:
|
|
$$\left[\prod_{m=1}^l
|
|
\left[g_{s^{\vert c_m\vert}}\right]^{\gamma_m}_{c_m(\alpha)}
|
|
\right]_S^{\gamma_1\ldots\gamma_l}$$
|
|
Since all $\gamma_1,\ldots,\gamma_l$ correspond to the same variable,
|
|
the tensor is fully symmetric. The set of indices $S$ cannot be very
|
|
large and sometimes it is only one element. This case is handled in a
|
|
special subclass.
|
|
|
|
We provide both folded and unfolded versions. Their logic is perfectly
|
|
the same as in |UFSTensor| and |FFSTensor| with two exceptions. One
|
|
has been already mentioned, the multidimensional index is along the
|
|
rows. The second are conversions between the two types. Since this
|
|
kind of tensor is used to multiply (from the right) a tensor whose
|
|
multidimensional index is identified with columns, we will need a
|
|
different way of a conversion. If the multiplication of two folded
|
|
tensors is to be equivalent with multiplication of two unfolded, the
|
|
folding of the right tensor must sum all equivalent elements since
|
|
they are multiplied with the same number from the folded
|
|
tensor. (Equivalent here means all elements of unfolded tensor
|
|
corresponding to one element in folded tensor.) For this reason, it is
|
|
necessary to calculate a column number from the given sequence, so we
|
|
implement |getOffset|. Process of unfolding is not used, so we
|
|
implemented it so that unfolding and then folding a tensor would yield
|
|
the same data.
|
|
|
|
@c
|
|
#ifndef RFS_TENSOR_H
|
|
#define RFS_TENSOR_H
|
|
|
|
#include "tensor.h"
|
|
#include "fs_tensor.h"
|
|
#include "symmetry.h"
|
|
|
|
@<|URTensor| class declaration@>;
|
|
@<|FRTensor| class declaration@>;
|
|
@<|URSingleTensor| class declaration@>;
|
|
@<|FRSingleTensor| class declaration@>;
|
|
|
|
#endif
|
|
|
|
@ This is straightforward and very similar to |UFSTensor|.
|
|
@<|URTensor| class declaration@>=
|
|
class FRTensor;
|
|
class URTensor : public UTensor {
|
|
int nv;
|
|
public:@;
|
|
@<|URTensor| constructor declaration@>;
|
|
virtual ~URTensor()@+ {}
|
|
|
|
void increment(IntSequence& v) const;
|
|
void decrement(IntSequence& v) const;
|
|
FTensor& fold() const;
|
|
|
|
int getOffset(const IntSequence& v) const;
|
|
int nvar() const
|
|
{@+ return nv;@+}
|
|
Symmetry getSym() const
|
|
{@+ return Symmetry(dimen());@+}
|
|
};
|
|
|
|
@
|
|
@<|URTensor| constructor declaration@>=
|
|
URTensor(int c, int nvar, int d)
|
|
: UTensor(along_row, IntSequence(d, nvar),
|
|
UFSTensor::calcMaxOffset(nvar, d), c, d), nv(nvar)@+ {}
|
|
URTensor(const URTensor& ut)
|
|
: UTensor(ut), nv(ut.nv)@+ {}
|
|
URTensor(const FRTensor& ft);
|
|
|
|
@ This is straightforward and very similar to |FFSTensor|.
|
|
@<|FRTensor| class declaration@>=
|
|
class FRTensor : public FTensor {
|
|
int nv;
|
|
public:@;
|
|
@<|FRTensor| constructor declaration@>;
|
|
virtual ~FRTensor()@+ {}
|
|
|
|
void increment(IntSequence& v) const;
|
|
void decrement(IntSequence& v) const;
|
|
UTensor& unfold() const;
|
|
|
|
int nvar() const
|
|
{@+ return nv;@+}
|
|
int getOffset(const IntSequence& v) const
|
|
{@+ return FTensor::getOffset(v, nv);@+}
|
|
Symmetry getSym() const
|
|
{@+ return Symmetry(dimen());@+}
|
|
};
|
|
|
|
@
|
|
@<|FRTensor| constructor declaration@>=
|
|
FRTensor(int c, int nvar, int d)
|
|
: FTensor(along_row, IntSequence(d, nvar),
|
|
FFSTensor::calcMaxOffset(nvar, d), c, d), nv(nvar)@+ {}
|
|
FRTensor(const FRTensor& ft)
|
|
: FTensor(ft), nv(ft.nv)@+ {}
|
|
FRTensor(const URTensor& ut);
|
|
|
|
@ The following class represents specialization of |URTensor| coming
|
|
from Kronecker multiplication of a few vectors. So the resulting
|
|
row-oriented tensor has one column. We provide two constructors,
|
|
one constructs the tensor from a few vectors stored as
|
|
|vector<ConstVector>|. The second makes the Kronecker power of one
|
|
given vector.
|
|
|
|
@<|URSingleTensor| class declaration@>=
|
|
class URSingleTensor : public URTensor {
|
|
public:@;
|
|
URSingleTensor(int nvar, int d)
|
|
: URTensor(1, nvar, d)@+ {}
|
|
URSingleTensor(const vector<ConstVector>& cols);
|
|
URSingleTensor(const ConstVector& v, int d);
|
|
URSingleTensor(const URSingleTensor& ut)
|
|
: URTensor(ut)@+ {}
|
|
virtual ~URSingleTensor()@+ {}
|
|
FTensor& fold() const;
|
|
};
|
|
|
|
@ This class represents one column row-oriented tensor. The only way
|
|
how to construct it is from the |URSingleTensor| or from the
|
|
scratch. The folding algorithm is the same as folding of general
|
|
|URTensor|. Only its implementation is different, since we do not copy
|
|
rows, but only elements.
|
|
|
|
@<|FRSingleTensor| class declaration@>=
|
|
class FRSingleTensor : public FRTensor {
|
|
public:@;
|
|
FRSingleTensor(int nvar, int d)
|
|
: FRTensor(1, nvar, d)@+ {}
|
|
FRSingleTensor(const URSingleTensor& ut);
|
|
FRSingleTensor(const FRSingleTensor& ft)
|
|
: FRTensor(ft)@+ {}
|
|
virtual ~FRSingleTensor()@+ {}
|
|
};
|
|
|
|
|
|
@ End of {\tt rfs\_tensor.h} file.
|